xref: /ohos5.0/foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_continue_token.cpp

/*
 * 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 "sqlite_single_ver_continue_token.h"
#include "sqlite_single_ver_storage_executor_sql.h"
#include "sqlite_utils.h"

namespace DistributedDB {
SQLiteSingleVerContinueToken::SQLiteSingleVerContinueToken(Timestamp begin, Timestamp end)
    : timeRanges_(MulDevTimeRanges{{"", {begin, end}}})
{}

SQLiteSingleVerContinueToken::SQLiteSingleVerContinueToken(
    const SyncTimeRange &timeRange, const QueryObject &queryObject)
    : queryObject_(std::map<DeviceID, QueryObject>{{"", queryObject}}),
      timeRanges_(MulDevTimeRanges{{"", {timeRange.beginTime, timeRange.endTime}}}),
      deleteTimeRanges_(MulDevTimeRanges{{"", {timeRange.deleteBeginTime, timeRange.deleteEndTime}}})
{}

SQLiteSingleVerContinueToken::SQLiteSingleVerContinueToken(MulDevTimeRanges timeRanges)
    : timeRanges_(timeRanges)
{}

SQLiteSingleVerContinueToken::~SQLiteSingleVerContinueToken()
{}

bool SQLiteSingleVerContinueToken::CheckValid() const
{
    return ((magicBegin_ == MAGIC_BEGIN) && (magicEnd_ == MAGIC_END));
}

Timestamp SQLiteSingleVerContinueToken::GetQueryBeginTime() const
{
    return GetBeginTimestamp(timeRanges_);
}

Timestamp SQLiteSingleVerContinueToken::GetQueryEndTime() const
{
    return GetEndTimestamp(timeRanges_);
}

Timestamp SQLiteSingleVerContinueToken::GetDeletedBeginTime() const
{
    return GetBeginTimestamp(deleteTimeRanges_);
}

Timestamp SQLiteSingleVerContinueToken::GetDeletedEndTime() const
{
    return GetEndTimestamp(deleteTimeRanges_);
}

void SQLiteSingleVerContinueToken::SetNextBeginTime(const DeviceID &deviceID, Timestamp nextBeginTime)
{
    RemovePrevDevAndSetBeginTime(deviceID, nextBeginTime, timeRanges_);
}

const MulDevTimeRanges& SQLiteSingleVerContinueToken::GetTimeRanges()
{
    return timeRanges_;
}

void SQLiteSingleVerContinueToken::SetDeletedNextBeginTime(const DeviceID &deviceID, Timestamp nextBeginTime)
{
    RemovePrevDevAndSetBeginTime(deviceID, nextBeginTime, deleteTimeRanges_);
}

const MulDevTimeRanges& SQLiteSingleVerContinueToken::GetDeletedTimeRanges() const
{
    return deleteTimeRanges_;
}

void SQLiteSingleVerContinueToken::FinishGetQueryData()
{
    timeRanges_.clear();
}

void SQLiteSingleVerContinueToken::FinishGetDeletedData()
{
    deleteTimeRanges_.clear();
}

bool SQLiteSingleVerContinueToken::IsGetQueryDataFinished() const
{
    return timeRanges_.empty();
}

bool SQLiteSingleVerContinueToken::IsGetDeletedDataFinished() const
{
    return deleteTimeRanges_.empty();
}

bool SQLiteSingleVerContinueToken::IsQuerySync() const
{
    return !queryObject_.empty();
}

QueryObject SQLiteSingleVerContinueToken::GetQuery() const
{
    if (!queryObject_.empty()) {
        return queryObject_.begin()->second;
    }
    return QueryObject{};
}

void SQLiteSingleVerContinueToken::RemovePrevDevAndSetBeginTime(const DeviceID &deviceID, Timestamp nextBeginTime,
    MulDevTimeRanges &timeRanges)
{
    auto iter = timeRanges.find(deviceID);
    if (iter == timeRanges.end()) {
        return;
    }
    iter = timeRanges.erase(timeRanges.begin(), iter);
    iter->second.first = nextBeginTime;
}

Timestamp SQLiteSingleVerContinueToken::GetBeginTimestamp(const MulDevTimeRanges &timeRanges) const
{
    if (timeRanges.empty()) {
        return 0;
    }
    return timeRanges.begin()->second.first;
}

Timestamp SQLiteSingleVerContinueToken::GetEndTimestamp(const MulDevTimeRanges &timeRanges) const
{
    if (timeRanges.empty()) {
        return static_cast<Timestamp>(INT64_MAX);
    }
    return timeRanges.begin()->second.second;
}

std::pair<int, sqlite3_stmt *> SQLiteSingleVerContinueToken::GetCloudQueryStmt(sqlite3 *db, bool forcePush,
    bool &stepNext, const CloudWaterType mode)
{
    if (queryDataStmt_ != nullptr) {
        return {E_OK, queryDataStmt_};
    }
    std::pair<int, sqlite3_stmt *> res;
    int &errCode = res.first;
    sqlite3_stmt *&stmt = res.second;
    SqliteQueryHelper helper = GetQuery().GetQueryHelper(errCode);
    if (errCode != E_OK) {
        return res;
    }
    std::tie(errCode, stmt) = helper.GetKvCloudQueryStmt(db, forcePush, mode, timeRanges_[""].first, user_);
    if (errCode != E_OK) {
        return res;
    }
    queryDataStmt_ = stmt;
    stepNext = true;
    return res;
}

void SQLiteSingleVerContinueToken::ReleaseCloudQueryStmt()
{
    if (queryDataStmt_ == nullptr) {
        return;
    }
    int errCode = E_OK;
    SQLiteUtils::ResetStatement(queryDataStmt_, true, errCode);
    queryDataStmt_ = nullptr;
    if (errCode != E_OK) {
        LOGW("[SQLiteSingleVerContinueToken] release cloud query stmt failed %d", errCode);
    }
}

void SQLiteSingleVerContinueToken::SetUser(const std::string &user)
{
    user_ = user;
}
}  // namespace DistributedDB