OpenHarmony-v6.0-Release/s

/*
 * Copyright (c) 2021 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.
 */
#include <memory>
#define LOG_TAG "DataAbilityPredicatesProxy"
#include "napi_data_ability_predicates.h"

#include "js_df_manager.h"
#include "js_utils.h"
#include "logger.h"
#include "napi_predicates_utils.h"

using namespace OHOS::Rdb;
using namespace OHOS::NativeRdb;
using namespace OHOS::AppDataMgrJsKit;

namespace OHOS {
namespace DataAbilityJsKit {
static __thread napi_ref constructor_ = nullptr;

void DataAbilityPredicatesProxy::Init(napi_env env, napi_value exports)
{
    LOG_INFO("Init DataAbilityPredicatesProxy");
    napi_property_descriptor descriptors[] = {
        DECLARE_NAPI_FUNCTION("equalTo", EqualTo),
        DECLARE_NAPI_FUNCTION("notEqualTo", NotEqualTo),
        DECLARE_NAPI_FUNCTION("beginWrap", BeginWrap),
        DECLARE_NAPI_FUNCTION("endWrap", EndWrap),
        DECLARE_NAPI_FUNCTION("or", Or),
        DECLARE_NAPI_FUNCTION("and", And),
        DECLARE_NAPI_FUNCTION("contains", Contains),
        DECLARE_NAPI_FUNCTION("beginsWith", BeginsWith),
        DECLARE_NAPI_FUNCTION("endsWith", EndsWith),
        DECLARE_NAPI_FUNCTION("isNull", IsNull),
        DECLARE_NAPI_FUNCTION("isNotNull", IsNotNull),
        DECLARE_NAPI_FUNCTION("like", Like),
        DECLARE_NAPI_FUNCTION("glob", Glob),
        DECLARE_NAPI_FUNCTION("between", Between),
        DECLARE_NAPI_FUNCTION("notBetween", NotBetween),
        DECLARE_NAPI_FUNCTION("greaterThan", GreaterThan),
        DECLARE_NAPI_FUNCTION("lessThan", LessThan),
        DECLARE_NAPI_FUNCTION("greaterThanOrEqualTo", GreaterThanOrEqualTo),
        DECLARE_NAPI_FUNCTION("lessThanOrEqualTo", LessThanOrEqualTo),
        DECLARE_NAPI_FUNCTION("orderByAsc", OrderByAsc),
        DECLARE_NAPI_FUNCTION("orderByDesc", OrderByDesc),
        DECLARE_NAPI_FUNCTION("distinct", Distinct),
        DECLARE_NAPI_FUNCTION("limitAs", Limit),
        DECLARE_NAPI_FUNCTION("offsetAs", Offset),
        DECLARE_NAPI_FUNCTION("groupBy", GroupBy),
        DECLARE_NAPI_FUNCTION("indexedBy", IndexedBy),
        DECLARE_NAPI_FUNCTION("in", In),
        DECLARE_NAPI_FUNCTION("notIn", NotIn),
        DECLARE_NAPI_FUNCTION("clear", Clear),
        DECLARE_NAPI_FUNCTION("isRawSelection", IsRawSelection),
        DECLARE_NAPI_GETTER_SETTER("whereClause", GetWhereClause, SetWhereClause),
        DECLARE_NAPI_GETTER_SETTER("whereArgs", GetWhereArgs, SetWhereArgs),
        DECLARE_NAPI_GETTER_SETTER("order", GetOrder, SetOrder),
        DECLARE_NAPI_GETTER("limit", GetLimit),
        DECLARE_NAPI_GETTER("offset", GetOffset),
        DECLARE_NAPI_GETTER("isDistinct", IsDistinct),
        DECLARE_NAPI_GETTER("group", GetGroup),
        DECLARE_NAPI_GETTER("index", GetIndex),
        DECLARE_NAPI_GETTER("isNeedAnd", IsNeedAnd),
        DECLARE_NAPI_GETTER("isSorted", IsSorted),
    };

    napi_value cons = nullptr;
    NAPI_CALL_RETURN_VOID(env, napi_define_class(env, "DataAbilityPredicates", NAPI_AUTO_LENGTH, New, nullptr,
                                   sizeof(descriptors) / sizeof(napi_property_descriptor), descriptors, &cons));

    NAPI_CALL_RETURN_VOID(env, napi_create_reference(env, cons, 1, &constructor_));

    NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, exports, "DataAbilityPredicates", cons));
}

napi_value DataAbilityPredicatesProxy::New(napi_env env, napi_callback_info info)
{
    napi_value new_target = nullptr;
    NAPI_CALL(env, napi_get_new_target(env, info, &new_target));
    bool is_constructor = (new_target != nullptr);

    napi_value thiz = nullptr;
    NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr));

    if (is_constructor) {
        auto *proxy = new (std::nothrow) DataAbilityPredicatesProxy();
        if (proxy == nullptr) {
            LOG_ERROR("DataAbilityPredicatesProxy::New new failed, proxy is nullptr.");
            return nullptr;
        }
        napi_status status = napi_wrap(env, thiz, proxy, DataAbilityPredicatesProxy::Destructor, nullptr, nullptr);
        if (status != napi_ok) {
            LOG_ERROR("DataAbilityPredicatesProxy::New napi_wrap failed! napi_status:%{public}d!", status);
            delete proxy;
            return nullptr;
        }
        JSDFManager::GetInstance().AddNewInfo(proxy);
        return thiz;
    }

    napi_value cons = nullptr;
    NAPI_CALL(env, napi_get_reference_value(env, constructor_, &cons));

    napi_value output = nullptr;
    NAPI_CALL(env, napi_new_instance(env, cons, 0, nullptr, &output));

    return output;
}

napi_value DataAbilityPredicatesProxy::NewInstance(
    napi_env env, std::shared_ptr<NativeRdb::DataAbilityPredicates> value)
{
    napi_value cons = nullptr;
    napi_status status = napi_get_reference_value(env, constructor_, &cons);
    if (status != napi_ok) {
        LOG_ERROR("DataAbilityPredicatesProxy get constructor failed! napi_status:%{public}d!", status);
        return nullptr;
    }

    napi_value instance = nullptr;
    status = napi_new_instance(env, cons, 0, nullptr, &instance);
    if (status != napi_ok) {
        LOG_ERROR("DataAbilityPredicatesProxy napi_new_instance failed! napi_status:%{public}d!", status);
        return nullptr;
    }

    DataAbilityPredicatesProxy *proxy = nullptr;
    status = napi_unwrap(env, instance, reinterpret_cast<void **>(&proxy));
    if (status != napi_ok || proxy == nullptr) {
        LOG_ERROR("DataAbilityPredicatesProxy native instance is nullptr! napi_status:%{public}d!", status);
        return instance;
    }
    proxy->predicates_ = std::move(value);
    return instance;
}

std::shared_ptr<NativeRdb::DataAbilityPredicates> DataAbilityPredicatesProxy::GetNativePredicates(
    const napi_env env, const napi_value arg)
{
    if (arg == nullptr) {
        LOG_ERROR("DataAbilityPredicatesProxy arg is null.");
        return nullptr;
    }
    DataAbilityPredicatesProxy *proxy = nullptr;
    napi_unwrap(env, arg, reinterpret_cast<void **>(&proxy));
    if (proxy == nullptr) {
        LOG_ERROR("DataAbilityPredicatesProxy proxy is null.");
        return nullptr;
    }
    return proxy->predicates_;
}

void DataAbilityPredicatesProxy::Destructor(napi_env env, void *nativeObject, void *)
{
    auto tid = JSDFManager::GetInstance().GetFreedTid(nativeObject);
    if (tid != 0) {
        LOG_ERROR("(T:%{public}d) freed! data:0x%016" PRIXPTR, tid, uintptr_t(nativeObject) & LOWER_24_BITS_MASK);
    }
    DataAbilityPredicatesProxy *proxy = static_cast<DataAbilityPredicatesProxy *>(nativeObject);
    if (proxy == nullptr) {
        return;
    }
    proxy->predicates_ = std::move(nullptr);
    delete proxy;
}

DataAbilityPredicatesProxy::~DataAbilityPredicatesProxy()
{
}

DataAbilityPredicatesProxy::DataAbilityPredicatesProxy()
{
    predicates_ = std::make_shared<DataAbilityPredicates>();
}

std::shared_ptr<NativeRdb::DataAbilityPredicates> DataAbilityPredicatesProxy::GetNativePredicates(
    napi_env env, napi_callback_info info)
{
    DataAbilityPredicatesProxy *predicatesProxy = nullptr;
    napi_value thiz = nullptr;
    napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
    napi_unwrap(env, thiz, reinterpret_cast<void **>(&predicatesProxy));
    if (predicatesProxy == nullptr) {
        return nullptr;
    }
    return predicatesProxy->predicates_;
}

napi_value DataAbilityPredicatesProxy::EqualTo(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 2;
    napi_value args[2] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::EqualTo Invalid argvs!");
    std::string field;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
    ValueObject value;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->EqualTo(field, value);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::NotEqualTo(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 2;
    napi_value args[2] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::NotEqualTo Invalid argvs!");
    std::string field;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
    ValueObject value;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->NotEqualTo(field, value);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::BeginWrap(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->BeginWrap();
    return thiz;
}

napi_value DataAbilityPredicatesProxy::EndWrap(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->EndWrap();
    return thiz;
}

napi_value DataAbilityPredicatesProxy::Or(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->Or();
    return thiz;
}

napi_value DataAbilityPredicatesProxy::And(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->And();
    return thiz;
}

napi_value DataAbilityPredicatesProxy::Contains(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 2;
    napi_value args[2] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Contains Invalid argvs!");
    std::string field;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
    std::string value;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->Contains(field, value);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::BeginsWith(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 2;
    napi_value args[2] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::BeginsWith Invalid argvs!");
    std::string field;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
    std::string value;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->BeginsWith(field, value);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::EndsWith(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 2;
    napi_value args[2] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::EndsWith Invalid argvs!");
    std::string field;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
    std::string value;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->EndsWith(field, value);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::IsNull(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 1;
    napi_value args[1] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::IsNull Invalid argvs!");
    std::string field;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->IsNull(field);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::IsNotNull(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 1;
    napi_value args[1] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::IsNotNull Invalid argvs!");
    std::string field;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->IsNotNull(field);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::Like(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 2;
    napi_value args[2] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Like Invalid argvs!");
    std::string field;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
    std::string value;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->Like(field, value);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::Glob(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 2;
    napi_value args[2] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Glob Invalid argvs!");
    std::string field;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
    std::string value;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->Glob(field, value);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::Between(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 3;
    // 3 represents the number of parameters
    napi_value args[3] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Between Invalid argvs!");
    std::string field;
    // args[0] represents the first parameter
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
    ValueObject low;
    // args[1] represents the second parameter
    JSUtils::Convert2Value(env, args[1], low);
    ValueObject high;
    // args[2] represents the third parameter
    JSUtils::Convert2Value(env, args[2], high);
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->Between(field, low, high);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::NotBetween(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 3;
    // 3 represents the number of parameters
    napi_value args[3] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::NotBetween Invalid argvs!");
    std::string field;
    // args[0] represents the first parameter
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
    ValueObject low;
    // args[1] represents the second parameter
    JSUtils::Convert2Value(env, args[1], low);
    ValueObject high;
    // args[2] represents the third parameter
    JSUtils::Convert2Value(env, args[2], high);
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->NotBetween(field, low, high);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::GreaterThan(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 2;
    napi_value args[2] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::GreaterThan Invalid argvs!");
    std::string field;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
    ValueObject value;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->GreaterThan(field, value);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::LessThan(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 2;
    napi_value args[2] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::LessThan Invalid argvs!");
    std::string field;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
    ValueObject value;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->LessThan(field, value);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::GreaterThanOrEqualTo(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 2;
    napi_value args[2] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::GreaterThanOrEqualTo Invalid argvs!");
    std::string field;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
    ValueObject value;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->GreaterThanOrEqualTo(field, value);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::LessThanOrEqualTo(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 2;
    napi_value args[2] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::LessThanOrEqualTo Invalid argvs!");
    std::string field;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");
    ValueObject value;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[1], value) == napi_ok, "the value is invalid");
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->LessThanOrEqualTo(field, value);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::OrderByAsc(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 1;
    napi_value args[1] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::OrderByAsc Invalid argvs!");

    std::string field;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");

    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->OrderByAsc(field);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::OrderByDesc(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 1;
    napi_value args[1] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::OrderByDesc Invalid argvs!");

    std::string field;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");

    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->OrderByDesc(field);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::Distinct(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->Distinct();
    return thiz;
}

napi_value DataAbilityPredicatesProxy::Limit(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 1;
    napi_value args[1] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Limit Invalid argvs!");

    int32_t limit = 0;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2ValueExt(env, args[0], limit) == napi_ok, "the limit is invalid");

    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->Limit(limit);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::Offset(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 1;
    napi_value args[1] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::Offset Invalid argvs!");

    int32_t offset = 0;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2ValueExt(env, args[0], offset) == napi_ok, "the offset is invalid");

    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->Offset(offset);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::GroupBy(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 1;
    napi_value args[1] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::GroupBy Invalid argvs!");

    std::vector<std::string> fields = {};
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], fields) == napi_ok, "the fields is invalid");

    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->GroupBy(fields);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::IndexedBy(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 1;
    napi_value args[1] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::IndexedBy Invalid argvs!");

    std::string indexName;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], indexName) == napi_ok, "the indexName is invalid");

    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->IndexedBy(indexName);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::In(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 2;
    napi_value args[2] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::In Invalid argvs!");

    std::string field;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");

    std::vector<ValueObject> values;
    NAPI_ASSERT(env, JSUtils::Convert2Value(env, args[1], values) == napi_ok, "Invalid values!");

    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->In(field, values);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::NotIn(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 2;
    napi_value args[2] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::NotIn Invalid argvs!");

    std::string field;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], field) == napi_ok, "the field is invalid");

    std::vector<ValueObject> values;
    NAPI_ASSERT(env, JSUtils::Convert2Value(env, args[1], values) == napi_ok, "Invalid values");

    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->NotIn(field, values);
    return thiz;
}

napi_value DataAbilityPredicatesProxy::Clear(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->Clear();
    return thiz;
}

napi_value DataAbilityPredicatesProxy::IsRawSelection(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    napi_get_cb_info(env, info, nullptr, nullptr, &thiz, nullptr);
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    bool out = nativePredicates->IsRawSelection();
    return JSUtils::Convert2JSValue(env, out);
}

std::shared_ptr<NativeRdb::DataAbilityPredicates> DataAbilityPredicatesProxy::GetPredicates() const
{
    return this->predicates_;
}

napi_value DataAbilityPredicatesProxy::GetWhereClause(napi_env env, napi_callback_info info)
{
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    auto ret = nativePredicates->GetWhereClause();
    return JSUtils::Convert2JSValue(env, ret);
}

napi_value DataAbilityPredicatesProxy::SetWhereClause(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 1;
    napi_value args[1] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::SetWhereClause Invalid argvs!");

    std::string whereClause;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], whereClause) == napi_ok, "whereClause is invalid");

    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->SetWhereClause(whereClause);

    return thiz;
}

napi_value DataAbilityPredicatesProxy::GetWhereArgs(napi_env env, napi_callback_info info)
{
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    auto ret = nativePredicates->GetWhereArgs();
    return JSUtils::Convert2JSValue(env, ret);
}

napi_value DataAbilityPredicatesProxy::SetWhereArgs(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 1;
    napi_value args[1] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::SetWhereArgs Invalid argvs!");

    std::vector<std::string> whereArgs;
    NAPI_ASSERT(env, JSUtils::Convert2Value(env, args[0], whereArgs) == napi_ok, "Invalid whereArgs!");

    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->SetWhereArgs(whereArgs);

    return thiz;
}

napi_value DataAbilityPredicatesProxy::GetOrder(napi_env env, napi_callback_info info)
{
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    auto ret = nativePredicates->GetOrder();
    return JSUtils::Convert2JSValue(env, ret);
}

napi_value DataAbilityPredicatesProxy::SetOrder(napi_env env, napi_callback_info info)
{
    napi_value thiz = nullptr;
    size_t argc = 1;
    napi_value args[1] = { 0 };
    napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
    NAPI_ASSERT(env, argc > 0, "DataAbilityPredicatesProxy::SetOrder Invalid argvs!");

    std::string order;
    RDB_CHECK_RETURN_NULLPTR(JSUtils::Convert2Value(env, args[0], order) != napi_ok, "the order is invalid");

    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    nativePredicates->SetOrder(order);

    return thiz;
}

napi_value DataAbilityPredicatesProxy::GetLimit(napi_env env, napi_callback_info info)
{
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    return JSUtils::Convert2JSValue(env, nativePredicates->GetLimit());
}

napi_value DataAbilityPredicatesProxy::GetOffset(napi_env env, napi_callback_info info)
{
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    return JSUtils::Convert2JSValue(env, nativePredicates->GetOffset());
}

napi_value DataAbilityPredicatesProxy::IsDistinct(napi_env env, napi_callback_info info)
{
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    return JSUtils::Convert2JSValue(env, nativePredicates->IsDistinct());
}

napi_value DataAbilityPredicatesProxy::GetGroup(napi_env env, napi_callback_info info)
{
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    auto ret = nativePredicates->GetGroup();
    return JSUtils::Convert2JSValue(env, ret);
}

napi_value DataAbilityPredicatesProxy::GetIndex(napi_env env, napi_callback_info info)
{
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    auto ret = nativePredicates->GetIndex();
    return JSUtils::Convert2JSValue(env, ret);
}

napi_value DataAbilityPredicatesProxy::IsNeedAnd(napi_env env, napi_callback_info info)
{
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    return JSUtils::Convert2JSValue(env, nativePredicates->IsNeedAnd());
}

napi_value DataAbilityPredicatesProxy::IsSorted(napi_env env, napi_callback_info info)
{
    auto nativePredicates = GetNativePredicates(env, info);
    RDB_CHECK_RETURN_NULLPTR(nativePredicates != nullptr, "GetNativePredicates return nullptr");
    return JSUtils::Convert2JSValue(env, nativePredicates->IsSorted());
}
} // namespace DataAbilityJsKit
} // namespace OHOS

EXTERN_C_START
API_EXPORT napi_value NAPI_OHOS_Data_DataAbilityJsKit_DataAbilityPredicatesProxy_NewInstance(napi_env env,
    DataAbilityPredicates *predicates)
{
    return OHOS::DataAbilityJsKit::DataAbilityPredicatesProxy::NewInstance(
        env, std::shared_ptr<DataAbilityPredicates>(predicates));
}

API_EXPORT DataAbilityPredicates *NAPI_OHOS_Data_DataAbilityJsKit_DataAbilityPredicatesProxy_GetNativeObject(
    const napi_env env, const napi_value arg)
{
    auto predicates = OHOS::DataAbilityJsKit::DataAbilityPredicatesProxy::GetNativePredicates(env, arg);
    return predicates.get();
}
EXTERN_C_END