xref: /base/security/asset/services/db_operator/src/statement.rs

/*
 * Copyright (c) 2023 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

//! This module implements database statements and provides precompiled query capabilities.

use core::ffi::c_void;
use std::ffi::CStr;

use asset_definition::{log_throw_error, ErrCode, Result, Value};
use asset_log::loge;

use crate::{
    database::Database,
    types::{sqlite_err_handle, SQLITE_DONE, SQLITE_OK, SQLITE_ROW},
};

type BindCallback = extern "C" fn(p: *mut c_void);
extern "C" {
    fn SqliteFinalize(stmt: *mut c_void) -> i32;
    fn SqlitePrepareV2(db: *mut c_void, z_sql: *const u8, pp_stmt: *mut *mut c_void, pz_tail: *mut *mut u8) -> i32;
    fn SqliteBindBlob(stmt: *mut c_void, index: i32, blob: *const u8, n: i32, callback: Option<BindCallback>) -> i32;
    fn SqliteBindInt64(stmt: *mut c_void, index: i32, value: i64) -> i32;
    fn SqliteStep(stmt: *mut c_void) -> i32;
    fn SqliteColumnName(stmt: *mut c_void, n: i32) -> *const u8;
    fn SqliteDataCount(stmt: *mut c_void) -> i32;
    fn SqliteColumnBlob(stmt: *mut c_void, i_col: i32) -> *const u8;
    fn SqliteColumnInt64(stmt: *mut c_void, i_col: i32) -> i64;
    fn SqliteColumnBytes(stmt: *mut c_void, i_col: i32) -> i32;
    fn SqliteColumnType(stmt: *mut c_void, i_col: i32) -> i32;
    fn SqliteReset(stmt: *mut c_void) -> i32;
}

const SQLITE_INTEGER: i32 = 1;
const SQLITE_BLOB: i32 = 4;
const SQLITE_NULL: i32 = 5;

#[repr(C)]
pub(crate) struct Statement<'b> {
    pub(crate) sql: String,
    db: &'b Database,
    handle: usize, // Poiner to statement.
}

impl<'b> Statement<'b> {
    /// Prepare a sql, you can use '?' for datas and bind datas later.
    pub(crate) fn prepare(sql: &str, db: &'b Database) -> Result<Statement<'b>> {
        let mut tail = 0usize;
        let mut sql_s = sql.to_string();
        sql_s.push('\0');
        let mut stmt = Statement { sql: sql_s, handle: 0, db };
        let ret = unsafe {
            SqlitePrepareV2(
                db.handle as _,
                stmt.sql.as_ptr(),
                &mut stmt.handle as *mut usize as _,
                &mut tail as *mut usize as _,
            )
        };
        if ret == 0 {
            Ok(stmt)
        } else {
            db.print_db_msg();
            log_throw_error!(sqlite_err_handle(ret), "Prepare statement failed, err={}", ret)
        }
    }

    /// Executing the precompiled sql. if succ
    /// If the execution is successful, return SQLITE_DONE for update, insert, delete and return SQLITE_ROW for select.
    pub(crate) fn step(&self) -> Result<i32> {
        let ret = unsafe { SqliteStep(self.handle as _) };
        if ret != SQLITE_ROW && ret != SQLITE_DONE {
            self.db.print_db_msg();
            log_throw_error!(sqlite_err_handle(ret), "Step statement failed, err={}", ret)
        } else {
            Ok(ret)
        }
    }

    /// Reset statement before bind data for insert statement.
    #[allow(dead_code)]
    pub(crate) fn reset(&self) -> Result<()> {
        let ret = unsafe { SqliteReset(self.handle as _) };
        if ret != SQLITE_OK {
            self.db.print_db_msg();
            log_throw_error!(sqlite_err_handle(ret), "Reset statement failed, err={}", ret)
        } else {
            Ok(())
        }
    }

    /// Bind data to prepared statement. The index is start from 1.
    pub(crate) fn bind_data(&self, index: i32, data: &Value) -> Result<()> {
        let ret = match data {
            Value::Bytes(b) => unsafe { SqliteBindBlob(self.handle as _, index, b.as_ptr(), b.len() as _, None) },
            Value::Number(i) => unsafe { SqliteBindInt64(self.handle as _, index, *i as _) },
            Value::Bool(b) => unsafe { SqliteBindInt64(self.handle as _, index, *b as _) },
        };
        if ret != SQLITE_OK {
            self.db.print_db_msg();
            log_throw_error!(sqlite_err_handle(ret), "Bind data failed, index={}, err={}", index, ret)
        } else {
            Ok(())
        }
    }

    /// Query the column name.
    pub(crate) fn query_column_name(&self, n: i32) -> Result<&str> {
        let s = unsafe { SqliteColumnName(self.handle as _, n) };
        if !s.is_null() {
            let name = unsafe { CStr::from_ptr(s as _) };
            if let Ok(rn) = name.to_str() {
                return Ok(rn);
            }
        }
        log_throw_error!(ErrCode::DatabaseError, "[FATAL][DB]Get asset column name failed.")
    }

    /// Get the count of columns in the query result.
    pub(crate) fn data_count(&self) -> i32 {
        unsafe { SqliteDataCount(self.handle as _) }
    }

    /// Query column and return a value of the Value type.
    pub(crate) fn query_column_auto_type(&self, i: i32) -> Result<Option<Value>> {
        let tp = self.column_type(i);
        let data = match tp {
            SQLITE_INTEGER => Some(Value::Number(self.query_column_int(i))),
            SQLITE_BLOB => {
                let blob = self.query_column_blob(i);
                if blob.is_empty() {
                    None
                } else {
                    Some(Value::Bytes(blob.to_vec()))
                }
            },
            SQLITE_NULL => None,
            t => return log_throw_error!(ErrCode::DatabaseError, "Unexpect column type: {}.", t),
        };
        Ok(data)
    }

    /// Query column datas in result set of blob type
    /// The index is start from 0.
    pub(crate) fn query_column_blob(&self, index: i32) -> &[u8] {
        let blob = unsafe { SqliteColumnBlob(self.handle as _, index) };
        let len = self.column_bytes(index);
        unsafe { core::slice::from_raw_parts(blob, len as _) }
    }

    /// Query column datas in result set of int type.
    /// The index is start with 0.
    pub(crate) fn query_column_int(&self, index: i32) -> u32 {
        unsafe { SqliteColumnInt64(self.handle as _, index) as u32 }
    }

    /// Get the bytes of data, you should first call query_column_text or query_column_blob,
    pub(crate) fn column_bytes(&self, index: i32) -> i32 {
        unsafe { SqliteColumnBytes(self.handle as _, index) }
    }

    /// Get the type of column.
    pub(crate) fn column_type(&self, index: i32) -> i32 {
        unsafe { SqliteColumnType(self.handle as _, index) }
    }
}

impl<'b> Drop for Statement<'b> {
    fn drop(&mut self) {
        if self.handle != 0 {
            let ret = unsafe { SqliteFinalize(self.handle as _) };
            if ret != SQLITE_OK {
                loge!("sqlite3 finalize fail ret {}", ret);
            }
        }
    }
}