1 /* 2 * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef TABLE_H 17 #define TABLE_H 18 19 #include <log.h> 20 #include <memory> 21 #include <string> 22 #include <vector> 23 24 #include "filter_constraints.h" 25 #include "index_map.h" 26 #include "sqlite3.h" 27 #include "trace_data_cache.h" 28 29 namespace SysTuning { 30 namespace TraceStreamer { 31 class DemoTableBase; 32 using TabTemplate = std::unique_ptr<DemoTableBase> (*)(const TraceDataCache *dataCache); 33 class DemoTableBase : public sqlite3_vtab { 34 public: 35 virtual ~DemoTableBase(); 36 DemoTableBase(const DemoTableBase &) = delete; 37 DemoTableBase &operator=(const DemoTableBase &) = delete; 38 39 template <typename T> TableDeclare(sqlite3 & db,TraceDataCache * dataCache,const std::string & name)40 static void TableDeclare(sqlite3 &db, TraceDataCache *dataCache, const std::string &name) 41 { 42 DemoTableRegister(db, dataCache, name, [](const TraceDataCache *cache) { 43 return std::unique_ptr<DemoTableBase>(std::make_unique<T>(cache)); 44 }); 45 dataCache->DemoAppendNewTable(name); 46 } 47 static void SetModuleCallbacks(sqlite3_module &demoModule, const std::string &demoTableName); 48 std::string DemoCreateTableSql() const; 49 50 class Cursor : public sqlite3_vtab_cursor { 51 public: 52 Cursor(const TraceDataCache *dataCache, DemoTableBase *table, uint32_t rowCount); 53 virtual ~Cursor(); Reset()54 virtual void Reset() 55 { 56 demoIndexMap_ = std::make_unique<IndexMap>(0, demoRowCount_); 57 } 58 Next()59 virtual int32_t Next() 60 { 61 demoIndexMap_->Next(); 62 return SQLITE_OK; 63 } 64 Eof()65 virtual int32_t Eof() 66 { 67 return demoDataCache_->DemoCancel() || demoIndexMap_->Eof(); 68 } 69 CurrentRow()70 virtual uint32_t CurrentRow() const 71 { 72 return demoIndexMap_->CurrentRow(); 73 } 74 virtual void DemoFilterTS(unsigned char op, sqlite3_value *argv, const std::deque<InternalTime> ×); 75 76 virtual int32_t DemoRowId(sqlite3_int64 *id); DemoFilter(const FilterConstraints & fc,sqlite3_value ** argv)77 virtual int32_t DemoFilter(const FilterConstraints &fc, sqlite3_value **argv) 78 { 79 Unused(fc); 80 Unused(argv); 81 return 0; 82 } 83 virtual int32_t Column(int32_t n) const = 0; 84 virtual void DemoFilterId(unsigned char op, sqlite3_value *argv); 85 86 public: 87 sqlite3_context *demoContext_; 88 DemoTableBase *demoTable_ = nullptr; 89 90 protected: 91 const TraceDataCache *demoDataCache_; 92 std::unique_ptr<IndexMap> demoIndexMap_; 93 uint32_t demoRowCount_; 94 }; 95 96 struct ColumnInfo { ColumnInfoColumnInfo97 ColumnInfo(const std::string &name, const std::string &type) : columnName(name), columnType(type) {} 98 std::string columnName; 99 std::string columnType; 100 }; 101 102 protected: DemoTableBase(const TraceDataCache * dataCache)103 explicit DemoTableBase(const TraceDataCache *dataCache) : demoTraceDataCache_(dataCache), demoCursor_(nullptr) {} 104 105 struct EstimatedIndexInfo { 106 int64_t estimatedRows = 0; 107 double estimatedCost = 0.0; 108 bool isOrdered = false; 109 }; 110 111 static void DemoTableRegister(sqlite3 &db, 112 TraceDataCache *cache, 113 const std::string &tableName, 114 TabTemplate tmplate); DemoUpdate(int32_t argc,sqlite3_value ** argv,sqlite3_int64 * pRowid)115 virtual int32_t DemoUpdate(int32_t argc, sqlite3_value **argv, sqlite3_int64 *pRowid) 116 { 117 return SQLITE_READONLY; 118 } 119 int32_t DemoBestIndex(sqlite3_index_info *idxInfo); 120 // needs to correspond to Cursor::DemoFilter() DemoEstimateFilterCost(FilterConstraints & fc,EstimatedIndexInfo & ei)121 virtual void DemoEstimateFilterCost(FilterConstraints &fc, EstimatedIndexInfo &ei) 122 { 123 Unused(fc); 124 Unused(ei); 125 } 126 virtual std::unique_ptr<Cursor> CreateCursor() = 0; 127 int32_t DemoOpen(sqlite3_vtab_cursor **ppCursor); DemoInit(int32_t,const char * const *)128 virtual void DemoInit(int32_t, const char *const *) 129 { 130 return; 131 }; 132 133 protected: 134 std::vector<ColumnInfo> demoTableColumn_ = {}; 135 std::vector<std::string> demoTablePriKey_ = {}; 136 const TraceDataCache *demoTraceDataCache_; 137 TraceDataCache *demoWdataCache_ = nullptr; 138 std::unique_ptr<Cursor> demoCursor_; 139 140 private: 141 uint16_t demoBestIndexNum_ = 0; 142 int32_t demoCacheIdxNum_ = 0; 143 FilterConstraints demoCacheConstraint_; 144 std::string name_; 145 }; 146 } // namespace TraceStreamer 147 } // namespace SysTuning 148 149 #endif // TABLE_H 150