/* * Copyright (C) 2018 The Android Open Source Project * * 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. */ #ifndef SRC_TRACE_PROCESSOR_SQLITE_UTILS_H_ #define SRC_TRACE_PROCESSOR_SQLITE_UTILS_H_ #include <math.h> #include <sqlite3.h> #include <functional> #include <limits> #include <string> #include "perfetto/base/logging.h" #include "perfetto/base/optional.h" #include "src/trace_processor/scoped_db.h" #include "src/trace_processor/table.h" namespace perfetto { namespace trace_processor { namespace sqlite_utils { const auto kSqliteStatic = reinterpret_cast<sqlite3_destructor_type>(0); const auto kSqliteTransient = reinterpret_cast<sqlite3_destructor_type>(-1); template <typename T> using is_numeric = typename std::enable_if<std::is_arithmetic<T>::value, T>::type; template <typename T> using is_float = typename std::enable_if<std::is_floating_point<T>::value, T>::type; template <typename T> using is_int = typename std::enable_if<std::is_integral<T>::value, T>::type; inline bool IsOpEq(int op) { return op == SQLITE_INDEX_CONSTRAINT_EQ; } inline bool IsOpGe(int op) { return op == SQLITE_INDEX_CONSTRAINT_GE; } inline bool IsOpGt(int op) { return op == SQLITE_INDEX_CONSTRAINT_GT; } inline bool IsOpLe(int op) { return op == SQLITE_INDEX_CONSTRAINT_LE; } inline bool IsOpLt(int op) { return op == SQLITE_INDEX_CONSTRAINT_LT; } inline std::string OpToString(int op) { switch (op) { case SQLITE_INDEX_CONSTRAINT_EQ: return "="; case SQLITE_INDEX_CONSTRAINT_NE: return "!="; case SQLITE_INDEX_CONSTRAINT_GE: return ">="; case SQLITE_INDEX_CONSTRAINT_GT: return ">"; case SQLITE_INDEX_CONSTRAINT_LE: return "<="; case SQLITE_INDEX_CONSTRAINT_LT: return "<"; default: PERFETTO_FATAL("Operator to string conversion not impemented for %d", op); } } inline bool IsOpIsNull(int op) { return op == SQLITE_INDEX_CONSTRAINT_ISNULL; } inline bool IsOpIsNotNull(int op) { return op == SQLITE_INDEX_CONSTRAINT_ISNOTNULL; } template <typename T> T ExtractSqliteValue(sqlite3_value* value); template <> inline uint8_t ExtractSqliteValue(sqlite3_value* value) { auto type = sqlite3_value_type(value); PERFETTO_DCHECK(type == SQLITE_INTEGER); return static_cast<uint8_t>(sqlite3_value_int(value)); } template <> inline uint32_t ExtractSqliteValue(sqlite3_value* value) { auto type = sqlite3_value_type(value); PERFETTO_DCHECK(type == SQLITE_INTEGER); return static_cast<uint32_t>(sqlite3_value_int64(value)); } template <> inline int32_t ExtractSqliteValue(sqlite3_value* value) { auto type = sqlite3_value_type(value); PERFETTO_DCHECK(type == SQLITE_INTEGER); return sqlite3_value_int(value); } template <> inline int64_t ExtractSqliteValue(sqlite3_value* value) { auto type = sqlite3_value_type(value); PERFETTO_DCHECK(type == SQLITE_INTEGER); return static_cast<int64_t>(sqlite3_value_int64(value)); } template <> inline double ExtractSqliteValue(sqlite3_value* value) { auto type = sqlite3_value_type(value); PERFETTO_DCHECK(type == SQLITE_FLOAT || type == SQLITE_INTEGER); return sqlite3_value_double(value); } // Do not add a uint64_t version of ExtractSqliteValue. You should not be using // uint64_t at all given that SQLite doesn't support it. template <> inline std::string ExtractSqliteValue(sqlite3_value* value) { auto type = sqlite3_value_type(value); PERFETTO_DCHECK(type == SQLITE_TEXT); const auto* extracted = reinterpret_cast<const char*>(sqlite3_value_text(value)); return std::string(extracted); } template <typename T> class NumericPredicate { public: NumericPredicate(int op, T constant) : op_(op), constant_(constant) {} PERFETTO_ALWAYS_INLINE bool operator()(T other) const { switch (op_) { case SQLITE_INDEX_CONSTRAINT_ISNULL: return false; case SQLITE_INDEX_CONSTRAINT_ISNOTNULL: return true; case SQLITE_INDEX_CONSTRAINT_EQ: case SQLITE_INDEX_CONSTRAINT_IS: return std::equal_to<T>()(other, constant_); case SQLITE_INDEX_CONSTRAINT_NE: case SQLITE_INDEX_CONSTRAINT_ISNOT: return std::not_equal_to<T>()(other, constant_); case SQLITE_INDEX_CONSTRAINT_GE: return std::greater_equal<T>()(other, constant_); case SQLITE_INDEX_CONSTRAINT_GT: return std::greater<T>()(other, constant_); case SQLITE_INDEX_CONSTRAINT_LE: return std::less_equal<T>()(other, constant_); case SQLITE_INDEX_CONSTRAINT_LT: return std::less<T>()(other, constant_); default: PERFETTO_FATAL("For GCC"); } } private: int op_; T constant_; }; template <typename T, typename sqlite_utils::is_numeric<T>* = nullptr> NumericPredicate<T> CreateNumericPredicate(int op, sqlite3_value* value) { T extracted = IsOpIsNull(op) || IsOpIsNotNull(op) ? 0 : ExtractSqliteValue<T>(value); return NumericPredicate<T>(op, extracted); } inline std::function<bool(const char*)> CreateStringPredicate( int op, sqlite3_value* value) { switch (op) { case SQLITE_INDEX_CONSTRAINT_ISNULL: return [](const char* f) { return f == nullptr; }; case SQLITE_INDEX_CONSTRAINT_ISNOTNULL: return [](const char* f) { return f != nullptr; }; } const char* val = reinterpret_cast<const char*>(sqlite3_value_text(value)); // If the value compared against is null, then to stay consistent with SQL // handling, we have to return false for non-null operators. if (val == nullptr) { PERFETTO_CHECK(op != SQLITE_INDEX_CONSTRAINT_IS && op != SQLITE_INDEX_CONSTRAINT_ISNOT); return [](const char*) { return false; }; } switch (op) { case SQLITE_INDEX_CONSTRAINT_EQ: case SQLITE_INDEX_CONSTRAINT_IS: return [val](const char* str) { return str != nullptr && strcmp(str, val) == 0; }; case SQLITE_INDEX_CONSTRAINT_NE: case SQLITE_INDEX_CONSTRAINT_ISNOT: return [val](const char* str) { return str != nullptr && strcmp(str, val) != 0; }; case SQLITE_INDEX_CONSTRAINT_GE: return [val](const char* str) { return str != nullptr && strcmp(str, val) >= 0; }; case SQLITE_INDEX_CONSTRAINT_GT: return [val](const char* str) { return str != nullptr && strcmp(str, val) > 0; }; case SQLITE_INDEX_CONSTRAINT_LE: return [val](const char* str) { return str != nullptr && strcmp(str, val) <= 0; }; case SQLITE_INDEX_CONSTRAINT_LT: return [val](const char* str) { return str != nullptr && strcmp(str, val) < 0; }; case SQLITE_INDEX_CONSTRAINT_LIKE: return [val](const char* str) { return str != nullptr && sqlite3_strlike(val, str, 0) == 0; }; case SQLITE_INDEX_CONSTRAINT_GLOB: return [val](const char* str) { return str != nullptr && sqlite3_strglob(val, str) == 0; }; default: PERFETTO_FATAL("For GCC"); } } // Greater bound for floating point numbers. template <typename T, typename sqlite_utils::is_float<T>* = nullptr> T FindGtBound(bool is_eq, sqlite3_value* sqlite_val) { constexpr auto kMax = static_cast<long double>(std::numeric_limits<T>::max()); auto type = sqlite3_value_type(sqlite_val); if (type != SQLITE_INTEGER && type != SQLITE_FLOAT) { return kMax; } // If this is a strict gt bound then just get the next highest float // after value. auto value = ExtractSqliteValue<T>(sqlite_val); return is_eq ? value : nexttoward(value, kMax); } template <typename T, typename sqlite_utils::is_int<T>* = nullptr> T FindGtBound(bool is_eq, sqlite3_value* sqlite_val) { auto type = sqlite3_value_type(sqlite_val); if (type == SQLITE_INTEGER) { auto value = ExtractSqliteValue<T>(sqlite_val); return is_eq ? value : value + 1; } else if (type == SQLITE_FLOAT) { auto value = ExtractSqliteValue<double>(sqlite_val); auto above = ceil(value); auto cast = static_cast<T>(above); return value < above ? cast : (is_eq ? cast : cast + 1); } else { return std::numeric_limits<T>::max(); } } template <typename T, typename sqlite_utils::is_float<T>* = nullptr> T FindLtBound(bool is_eq, sqlite3_value* sqlite_val) { constexpr auto kMin = static_cast<long double>(std::numeric_limits<T>::lowest()); auto type = sqlite3_value_type(sqlite_val); if (type != SQLITE_INTEGER && type != SQLITE_FLOAT) { return kMin; } // If this is a strict lt bound then just get the next lowest float // before value. auto value = ExtractSqliteValue<T>(sqlite_val); return is_eq ? value : nexttoward(value, kMin); } template <typename T, typename sqlite_utils::is_int<T>* = nullptr> T FindLtBound(bool is_eq, sqlite3_value* sqlite_val) { auto type = sqlite3_value_type(sqlite_val); if (type == SQLITE_INTEGER) { auto value = ExtractSqliteValue<T>(sqlite_val); return is_eq ? value : value - 1; } else if (type == SQLITE_FLOAT) { auto value = ExtractSqliteValue<double>(sqlite_val); auto below = floor(value); auto cast = static_cast<T>(below); return value > below ? cast : (is_eq ? cast : cast - 1); } else { return std::numeric_limits<T>::max(); } } template <typename T, typename sqlite_utils::is_float<T>* = nullptr> T FindEqBound(sqlite3_value* sqlite_val) { auto type = sqlite3_value_type(sqlite_val); if (type != SQLITE_INTEGER && type != SQLITE_FLOAT) { return std::numeric_limits<T>::max(); } return ExtractSqliteValue<T>(sqlite_val); } template <typename T, typename sqlite_utils::is_int<T>* = nullptr> T FindEqBound(sqlite3_value* sqlite_val) { auto type = sqlite3_value_type(sqlite_val); if (type == SQLITE_INTEGER) { return ExtractSqliteValue<T>(sqlite_val); } else if (type == SQLITE_FLOAT) { auto value = ExtractSqliteValue<double>(sqlite_val); auto below = floor(value); auto cast = static_cast<T>(below); return value > below ? std::numeric_limits<T>::max() : cast; } else { return std::numeric_limits<T>::max(); } } template <typename T> void ReportSqliteResult(sqlite3_context*, T value); // Do not add a uint64_t version of ReportSqliteResult. You should not be using // uint64_t at all given that SQLite doesn't support it. template <> inline void ReportSqliteResult(sqlite3_context* ctx, int32_t value) { sqlite3_result_int(ctx, value); } template <> inline void ReportSqliteResult(sqlite3_context* ctx, int64_t value) { sqlite3_result_int64(ctx, value); } template <> inline void ReportSqliteResult(sqlite3_context* ctx, uint8_t value) { sqlite3_result_int(ctx, value); } template <> inline void ReportSqliteResult(sqlite3_context* ctx, uint32_t value) { sqlite3_result_int64(ctx, value); } template <> inline void ReportSqliteResult(sqlite3_context* ctx, double value) { sqlite3_result_double(ctx, value); } inline std::string SqliteValueAsString(sqlite3_value* value) { switch (sqlite3_value_type(value)) { case SQLITE_INTEGER: return std::to_string(sqlite3_value_int64(value)); case SQLITE_FLOAT: return std::to_string(sqlite3_value_double(value)); case SQLITE_TEXT: { const char* str = reinterpret_cast<const char*>(sqlite3_value_text(value)); return "'" + std::string(str) + "'"; } default: PERFETTO_FATAL("Unknown value type %d", sqlite3_value_type(value)); } } inline std::vector<Table::Column> GetColumnsForTable( sqlite3* db, const std::string& raw_table_name) { char sql[1024]; const char kRawSql[] = "SELECT name, type from pragma_table_info(\"%s\")"; // Support names which are table valued functions with arguments. std::string table_name = raw_table_name.substr(0, raw_table_name.find('(')); int n = snprintf(sql, sizeof(sql), kRawSql, table_name.c_str()); PERFETTO_DCHECK(n >= 0 || static_cast<size_t>(n) < sizeof(sql)); sqlite3_stmt* raw_stmt = nullptr; int err = sqlite3_prepare_v2(db, sql, n, &raw_stmt, nullptr); ScopedStmt stmt(raw_stmt); PERFETTO_DCHECK(sqlite3_column_count(*stmt) == 2); std::vector<Table::Column> columns; for (;;) { err = sqlite3_step(raw_stmt); if (err == SQLITE_DONE) break; if (err != SQLITE_ROW) { PERFETTO_ELOG("Querying schema of table %s failed", raw_table_name.c_str()); return {}; } const char* name = reinterpret_cast<const char*>(sqlite3_column_text(*stmt, 0)); const char* raw_type = reinterpret_cast<const char*>(sqlite3_column_text(*stmt, 1)); if (!name || !raw_type || !*name) { PERFETTO_FATAL("Schema for %s has invalid column values", raw_table_name.c_str()); } Table::ColumnType type; if (strcmp(raw_type, "UNSIGNED INT") == 0) { type = Table::ColumnType::kUint; } else if (strcmp(raw_type, "BIG INT") == 0) { type = Table::ColumnType::kLong; } else if (strcmp(raw_type, "INT") == 0) { type = Table::ColumnType::kInt; } else if (strcmp(raw_type, "STRING") == 0) { type = Table::ColumnType::kString; } else if (strcmp(raw_type, "DOUBLE") == 0) { type = Table::ColumnType::kDouble; } else if (!*raw_type) { PERFETTO_DLOG("Unknown column type for %s %s", raw_table_name.c_str(), name); type = Table::ColumnType::kUnknown; } else { PERFETTO_FATAL("Unknown column type '%s' on table %s", raw_type, raw_table_name.c_str()); } columns.emplace_back(columns.size(), name, type); } return columns; } template <typename T> int CompareValuesAsc(const T& f, const T& s) { return f < s ? -1 : (f > s ? 1 : 0); } template <typename T> int CompareValuesDesc(const T& f, const T& s) { return -CompareValuesAsc(f, s); } } // namespace sqlite_utils } // namespace trace_processor } // namespace perfetto #endif // SRC_TRACE_PROCESSOR_SQLITE_UTILS_H_