winget-cli

Unnamed repository; edit this file 'description' to name the repository.
Log | Files | Refs | README | LICENSE

QueueTable.cpp (6072B)

      1 // Copyright (c) Microsoft Corporation.
      2 // Licensed under the MIT License.
      3 #include "pch.h"
      4 #include "QueueTable.h"
      5 #include <AppInstallerDateTime.h>
      6 #include <winget/SQLiteStatementBuilder.h>
      7 
      8 using namespace AppInstaller::SQLite;
      9 using namespace AppInstaller::SQLite::Builder;
     10 using namespace AppInstaller::Utility;
     11 
     12 namespace winrt::Microsoft::Management::Configuration::implementation::Database::Schema::V0_2
     13 {
     14     namespace
     15     {
     16         constexpr std::string_view s_QueueTable_Table = "queue"sv;
     17 
     18         constexpr std::string_view s_QueueTable_Column_SetInstanceIdentifier = "set_instance_identifier"sv;
     19         constexpr std::string_view s_QueueTable_Column_ObjectName = "object_name"sv;
     20         constexpr std::string_view s_QueueTable_Column_QueuedAt = "queued_at"sv;
     21         constexpr std::string_view s_QueueTable_Column_Active = "active"sv;
     22         constexpr std::string_view s_QueueTable_Column_Process = "process"sv;
     23     }
     24 
     25     QueueTable::QueueTable(Connection& connection) : m_connection(connection) {}
     26 
     27     void QueueTable::Create()
     28     {
     29         Savepoint savepoint = Savepoint::Create(m_connection, "QueueTable_Create_0_2");
     30 
     31         StatementBuilder tableBuilder;
     32         tableBuilder.CreateTable(s_QueueTable_Table).Columns({
     33             IntegerPrimaryKey(),
     34             ColumnBuilder(s_QueueTable_Column_SetInstanceIdentifier, Type::Blob).NotNull(),
     35             ColumnBuilder(s_QueueTable_Column_ObjectName, Type::Text).Unique().NotNull(),
     36             ColumnBuilder(s_QueueTable_Column_QueuedAt, Type::Int64).NotNull(),
     37             ColumnBuilder(s_QueueTable_Column_Active, Type::Bool).NotNull(),
     38         });
     39 
     40         tableBuilder.Execute(m_connection);
     41 
     42         savepoint.Commit();
     43     }
     44 
     45     void QueueTable::AddProcessColumn()
     46     {
     47         Savepoint savepoint = Savepoint::Create(m_connection, "QueueTable_AddProcessColumn_0_3");
     48 
     49         StatementBuilder builder;
     50         builder.AlterTable(s_QueueTable_Table).Add(s_QueueTable_Column_Process, Type::Int64).NotNull().Default(0);
     51 
     52         builder.Execute(m_connection);
     53 
     54         savepoint.Commit();
     55     }
     56 
     57     void QueueTable::AddQueueItemWithoutProcess(const GUID& instanceIdentifier, const std::string& objectName)
     58     {
     59         StatementBuilder builder;
     60         builder.InsertInto(s_QueueTable_Table).Columns({
     61             s_QueueTable_Column_SetInstanceIdentifier,
     62             s_QueueTable_Column_ObjectName,
     63             s_QueueTable_Column_QueuedAt,
     64             s_QueueTable_Column_Active
     65         }).Values(
     66             instanceIdentifier,
     67             objectName,
     68             GetCurrentUnixEpoch(),
     69             false
     70         );
     71 
     72         builder.Execute(m_connection);
     73     }
     74 
     75     void QueueTable::AddQueueItemWithProcess(const GUID& instanceIdentifier, const std::string& objectName)
     76     {
     77         StatementBuilder builder;
     78         builder.InsertInto(s_QueueTable_Table).Columns({
     79             s_QueueTable_Column_SetInstanceIdentifier,
     80             s_QueueTable_Column_ObjectName,
     81             s_QueueTable_Column_QueuedAt,
     82             s_QueueTable_Column_Active,
     83             s_QueueTable_Column_Process
     84             }).Values(
     85                 instanceIdentifier,
     86                 objectName,
     87                 GetCurrentUnixEpoch(),
     88                 false,
     89                 static_cast<int64_t>(GetCurrentProcessId())
     90             );
     91 
     92         builder.Execute(m_connection);
     93     }
     94 
     95     void QueueTable::SetActiveQueueItem(const std::string& objectName)
     96     {
     97         StatementBuilder builder;
     98         builder.Update(s_QueueTable_Table).Set().Column(s_QueueTable_Column_Active).Equals(true).Where(s_QueueTable_Column_ObjectName).Equals(objectName);
     99 
    100         builder.Execute(m_connection);
    101     }
    102 
    103     std::vector<std::tuple<GUID, std::string, std::chrono::system_clock::time_point, DWORD, bool>> QueueTable::GetQueueItemsWithoutProcess()
    104     {
    105         StatementBuilder builder;
    106         builder.Select({
    107             s_QueueTable_Column_SetInstanceIdentifier,
    108             s_QueueTable_Column_ObjectName,
    109             s_QueueTable_Column_QueuedAt,
    110             s_QueueTable_Column_Active
    111             }).From(s_QueueTable_Table).OrderBy({ s_QueueTable_Column_QueuedAt, RowIDName });
    112 
    113         Statement statement = builder.Prepare(m_connection);
    114 
    115         std::vector<std::tuple<GUID, std::string, std::chrono::system_clock::time_point, DWORD, bool>> result;
    116 
    117         while (statement.Step())
    118         {
    119             result.emplace_back(std::make_tuple(statement.GetColumn<GUID>(0), statement.GetColumn<std::string>(1), ConvertUnixEpochToSystemClock(statement.GetColumn<int64_t>(2)), 0, statement.GetColumn<bool>(3)));
    120         }
    121 
    122         return result;
    123     }
    124 
    125     std::vector<std::tuple<GUID, std::string, std::chrono::system_clock::time_point, DWORD, bool>> QueueTable::GetQueueItemsWithProcess()
    126     {
    127         StatementBuilder builder;
    128         builder.Select({
    129             s_QueueTable_Column_SetInstanceIdentifier,
    130             s_QueueTable_Column_ObjectName,
    131             s_QueueTable_Column_QueuedAt,
    132             s_QueueTable_Column_Active,
    133             s_QueueTable_Column_Process
    134         }).From(s_QueueTable_Table).OrderBy({ s_QueueTable_Column_QueuedAt, RowIDName });
    135 
    136         Statement statement = builder.Prepare(m_connection);
    137 
    138         std::vector<std::tuple<GUID, std::string, std::chrono::system_clock::time_point, DWORD, bool>> result;
    139 
    140         while (statement.Step())
    141         {
    142             result.emplace_back(std::make_tuple(statement.GetColumn<GUID>(0), statement.GetColumn<std::string>(1), ConvertUnixEpochToSystemClock(statement.GetColumn<int64_t>(2)), static_cast<DWORD>(statement.GetColumn<int64_t>(4)), statement.GetColumn<bool>(3)));
    143         }
    144 
    145         return result;
    146     }
    147 
    148     void QueueTable::RemoveQueueItem(const std::string& objectName)
    149     {
    150         StatementBuilder builder;
    151         builder.DeleteFrom(s_QueueTable_Table).Where(s_QueueTable_Column_ObjectName).Equals(objectName);
    152 
    153         builder.Execute(m_connection);
    154     }
    155 }