text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>TALL)");
}
else
#endif
{
if (mprotect(addr, len, PROT_NONE))
throw DB::ErrnoException(DB::ErrorCodes::SYSTEM_ERROR, "Cannot mprotect(PROT_NONE)");
}
}
/// Uses MADV_GUARD_REMOVE if available, or mprotect() if not
void memoryGuardRemove(void *addr, size_t len)
{
#ifdef ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>t>... TAlign>
requires DB::OptionalArgument<TAlign...>
inline ALWAYS_INLINE size_t trackMemoryFromC(std::size_t size, AllocationTrace & trace, TAlign... align)
{
[[maybe_unused]] MemoryTrackerUntrackedAllocationsBlockerInThread blocker;
std::size_t actual_size = getActualAllocationSize(size, align... | fim | ClickHouse/ClickHouse | c |
#if __has_include(<mysql.h>)
#include <mysql.h>
#else
#include <mysql/mysql.h>
#endif
#include <mysqlxx/Connection.h>
#include <mysqlxx/Exception.h>
static inline const char* ifNotEmpty(const char* s)
{
return s && *s ? s : nullptr;
}
namespace mysqlxx
{
LibrarySingleton::LibrarySingleton()
{
if (mysql_libr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#if __has_include(<mysql.h>)
<|fim_suffix|>igned num = mysql_errno(driver);
if (num)
throw Exception(errorMessage(driver), num);
}
void onError(MYSQL * driver)
{
throw Exception(errorMessage(driver), mysql_errno(driver));
}
}
<|fim_middle|>#include <mysql.h>
#else
#include <mysql/mysql.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>sl_key_)
, enable_local_infile(enable_local_infile_)
, opt_reconnect(opt_reconnect_)
, enable_compression(enable_compression_)
{
LOG_DEBUG(log,
"Created MySQL Pool with settings: connect_timeout={}, read_write_timeout={}, default_connections_number={}, max_connections_number={}",
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <map>
#include <mysqlxx/PoolFactory.h>
#include <Poco/Util/Application.h>
#include <Poco/Util/LayeredConfiguration.h>
namespace mysqlxx
{
struct PoolFactory::Impl
{
/// Cache of shared pools keyed by connection parameters (host, port, user, db, compression).
std::map<std::string, std::... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/Exception.h>
#include <Common/ReplicasReconnector.h>
#include <algorithm>
#include <ctime>
#include <random>
#include <thread>
#include <pcg_random.hpp>
#include <mysqlxx/PoolWithFailover.h>
#include <Common/randomSeed.h>
#include <IO/WriteBufferFromString.h>
#include <IO/Operators.h>
na... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>rorMessage(mysql_driver), err_no);
default:
throw BadQuery(errorMessage(mysql_driver, query), err_no);
}
}
}
UseQueryResult Query::use()
{
executeImpl();
MYSQL_RES * res = mysql_use_result(conn->getDriver());
if (!res)
onError(conn->getDriver());
r... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>)
throw Exception(std::string("Unknown column position ") + std::to_string(n));
return fields[n].name;
}
}
<|fim_prefix|>#if __has_include(<mysql.h>)
#include <mysql.h>
#else
#include <mysql/mysql.h>
#endif
#include <mysqlxx/Connection.h>
#include <mysqlxx/ResultBase.h>
namespace mysqlxx
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#if __has_include(<mysql.h>)
#include <mysql.h>
#else
#<|fim_suffix|>throw Exception(std::string("Array Index Overflow"));
MYSQL_FIELDS fields = res->getFields();
return fields[i].type;
}
}
<|fim_middle|>include <mysql/mysql.h>
#endif
#include <mysqlxx/Row.h>
namespace mysqlxx
{
Value Row::ope... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#if __has_include(<mysql.h>)
#include <mysql.h>
#else
#include <mysql/mysql.h>
#endif
#include <mysqlxx/Connection.h>
#include <mysqlxx/UseQu<|fim_suffix|>return Row(row, this, mysql_fetch_lengths(res));
}
}
<|fim_middle|>eryResult.h>
namespace mysqlxx
{
UseQueryResult::UseQueryResult(MYSQL_RES * res... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <mysqlxx/Value.h>
#include <mysqlxx/ResultBase.h>
#include <mysqlxx/Query.h>
#include <mysqlxx/Exception.h>
#include <base/preciseExp10.h>
#include <Common/DateLUTImpl.h>
namespace mysqlxx
{
time_t Value::getDateTimeImpl() const
{
const auto & date_lut = DateLUT::instance();
if (m_l... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
#include <boost/noncopyable.hpp>
#include <Poco/Util/Application.h>
#include <mysqlxx/Query.h>
#include <mysqlxx/Exception.h>
/// NOLINTBEGIN(modernize-macro-to-enum)
#define MYSQLXX_DEFAULT_TIMEOUT 60
#define MYSQLXX_DEFAULT_RW_TIMEOUT 1800
/// Disable LOAD DATA LOCAL... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <sstream>
#include <Poco/Exception.h>
#include <mysqlxx/Types.h>
namespace mysqlxx
{
/// Common exception class for MySQL library. Functions code() and errnum() return error numbers from MySQL, for details see mysqld_error.h
struct Exception : public Poco::Exception
{
explicit... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/Logger.h>
#include <list>
#include <memory>
#include <mutex>
#include <atomic>
#include <Poco/Exception.h>
#include <Poco/Logger.h>
#include <mysqlxx/Connection.h>
/// NOLINTBEGIN(modernize-macro-to-enum)
#define MYSQLXX_POOL_DEFAULT_START_CONNECTIONS 1
#define MYSQLXX_... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>st::noncopyable
{
public:
static PoolFactory & instance();
PoolFactory(const PoolFactory &) = delete;
/** Allocates a PoolWithFailover to connect to MySQL. */
PoolWithFailover get(const std::string & config_name,
unsigned default_connections = MYSQLXX_POOL_WITH_FAILOVER_DEFAULT_S... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <map>
#include <mysqlxx/Pool.h>
/// NOLINTBEGIN(modernize-macro-to-enum)
#define MYSQLXX_POOL_WITH_FAILOVER_DEFAULT_START_CONNECTIONS 1
#define MYSQLXX_POOL_WITH_FAILOVER_DEFAULT_MAX_CONNECTIONS 16
#define MYSQLXX_POOL_WITH_FAILOVER_DEFAULT_MAX_TRIES 3
#define MYSQLXX_POOL_WITH_F... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <sstream>
#include <mysqlxx/UseQueryResult.h>
namespace mysqlxx
{
/** Query.
* References Connection. If Connection is destroyed, Query becomes invalid and cannot be used.
*
* Usage example:
* mysqlxx::Query query = connection.query("SELECT 1 AS x, 2 AS y, 3 AS z LIMIT 1");
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> MYSQL_FIELDS fields;
unsigned num_fields;
};
}
<|fim_prefix|>#pragma once
#include <mysqlxx/Types.h>
namespace mysqlxx
{
class Connection;
class Query;
/** Base class for UseQueryResult.
* Contains the common part of the implementation,
* References Connection. If Connection is destroyed, t... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <mysqlxx/Types.h>
#include <mysqlxx/Value.h>
#include <mysqlxx/ResultBase.h>
#include <mysqlxx/Exception.h>
namespace mysqlxx
{
class ResultBase;
/** Result row.
* Unlike mysql++,
* this is a wrapper over MYSQL_ROW (char**), references ResultBase, does not own any data its... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>;
}
private:
Connection & conn;
bool finished;
};
}
<|fim_prefix|>#pragma once
#include <boost/noncopyable.hpp>
#include <mysqlxx/Connection.h>
namespace mysqlxx
{
/** Transaction RAII.
* If commit() was not called before destroy, it will be rolled back.
*/
class Transaction : priv... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <cstdint>
#include <string>
#ifndef _mysql_h
struct st_mysql;
using MYSQL = st_mysql;
struct st_mysql_res;
using MYSQL_RES = st_mysql_res;
using MYSQL_ROW = char**;
struct st_mysql_field;
using MYSQL_FIELD = st_mysql_field;
enum struct enum_field_types { MYSQL_TYPE_DECIMAL, MY... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>f you execute the next query in the connection, the object and all rows also become invalid.
* The object can only be used for the result of one query!
* (Attempting to assign the result of the next query to the object is UB.)
*/
class UseQueryResult : public ResultBase
{
public:
UseQueryResult(... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>s recursive calls from `Value::get<T>()` to `Value::operator T()` to `Value::get<T>()` to ...
template <typename T>
requires std::is_constructible_v<T, Value>
inline T contructFromValue(const Value & val)
{
return T(val);
}
}
template <typename T>
inline T Value::get() const
{
return details::con... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/Exception.h>
#include <Common/LockMemoryExceptionInThread.h>
/// It can be used in critical places to exit on unexpected exceptions.
/// SIGABRT is usually better that broken in-memory state with unpredictable consequences.
/// It also temporarily disables exception from mem... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>rn { std::string(begin, port - 1), port_number };
}
if (default_port)
{
return {str, default_port};
}
throw Exception(
ErrorCodes::BAD_ARGUMENTS,
"The address passed to function parseAddress doesn't contain port number and no 'default_port' was passed");
}
}
<|... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string>
#include <map>
#include <base/types.h>
namespace DB
{
/** Parse address from string, that can contain host with or<|fim_suffix|>* Examples:
* clickhouse.com - returns "clickhouse.com" and default_port
* clickhouse.com:80 - returns "clickhouse.com" and 80
* [2a02... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/parseGlobs.h>
#include <Common/re2.h>
#include <IO/WriteBufferFromString.h>
#include <IO/ReadBufferFromString.h>
#include <IO/Operators.h>
#include <algorithm>
#include <sstream>
#include <iomanip>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
namespace
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string>
#include <vector>
namespace DB
{
bool containsRangeGlob<|fim_suffix|>ring like `file{1,2,3}.csv` return vector of strings: {`file1.csv`,`file2.csv`,`file3.csv`}
std::vector<std::string> expandSelectionGlob(const std::string & path);
}
<|fim_middle|>(const std::str... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> + 1, m, separator, max_addresses);
else /// Otherwise just copy, spawn will occur when you call with the correct delimiter
buffer.push_back(description.substr(i, m - i + 1));
/// Add all possible received extensions to the current set of lines
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <vector>
namespace DB
{
/* Parse a string that generates shards and replicas. Se<|fim_suffix|>eDescriptionForExternalDatabase(const String & description, size_t max_addresses, UInt16 default_port);
}
<|fim_middle|>parator - one of two characters '|' or ',... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/proxyConfigurationToPocoProxyConfig.h>
#include <Common/StringUtils.h>
#include <Common/re2.h>
#include <base/find_symbols.h>
namespace DB
{
namespace
{
/*
* Copy `curl` behavior instead of `wget` as it seems to be more flexible.
* `curl` strips leading dot and accepts url gitlab.com... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>h>
namespace DB
{
Poco::Net::HTTPClientSession::ProxyConfig proxyConfigurationToPocoProxyConfig(const DB::ProxyConfiguration & proxy_configuration);
std::string buildPocoNonProxyHosts(const std::string & no_proxy_hosts_string);
}
<|fim_prefix|>#pragma once
#include <Poco<|fim_middle|>/Net/HTTPClientS... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/quoteString.h>
#include <IO/WriteHelpers.h>
#include <IO/WriteBufferFromString.h>
namespace DB
{
String quoteString(std::string_view x)
{
String res(2 + x.size(), '\0');
WriteBufferFromString wb(res);
writeQuotedString(x, wb);
return res;<|fim_suffix|>ing res(2 + x.size(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ote the identifier with backquotes.
String backQuote(std::string_view x);
/// Quote the identifier with backquotes, if required.
String backQuoteIfNeed(std::string_view x);
/// Quote the identifier with backquotes, for use in MySQL queries.
String backQuoteMySQL(std::string_view x);
}
<|fim_prefix|>#pr... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>_of_message ? ": " : ""));
}
}
}
void randomDelayForMaxSeconds(uint64_t seconds, LoggerPtr log, const char * start_of_message)
{
randomDelayForMaxMilliseconds(seconds * 1000, log, start_of_message);
}
<|fim_prefix|>#include <Common/randomDelay.h>
#include <Common/logger_useful.h>
#includ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>t char * start_of_message = nullptr);
<|fim_prefix|>#pragma once
#include <Common/Logger.h>
/// Sleeps for random duration between 0 and a specified number of milliseconds<|fim_middle|>, optionally outputs a logging message about that.
/// This function can be used to add random delays in tests.
void ra... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>_cast<UInt32>(dist6(rng));
}
<|fim_prefix|>#pragma once
#include <Common/randomSeed.h>
#include <pcg_random.hpp>
inline UInt32 randomNumber()
{
pcg64_fast rng{randomSeed()};
std::uniform_int_distribution<pcg64_fast::result_type> dist6(
std::numeric_limits<UInt32>::min(), std::numeric_li<... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <ctime>
#include <unistd.h>
#include <sys/types.h>
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <Common/randomSeed.h>
#include <Common/SipHash.h>
#include <base/getThreadId.h>
#include <base/types.h>
#if defined(__linux__)
#include <sys/utsname.h>
#endif
namespace D... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>mSeed();
<|fim_prefix|>#pragma <|fim_middle|>once
#include <cstdint>
#include <base/types.h>
/** Returns a number suitable as seed for PRNG. Use clock_gettime, pid and so on. */
UInt64 rando<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
#pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
#pragma clang diagnostic ignored "-Wnested-anon-types"
#pragma clang diagnostic ignored "-Wunused-parameter"
#pragma clang diagnostic ign... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include<|fim_suffix|>pace DB
{
FunctionRegisterMap & FunctionRegisterMap::instance()
{
static FunctionRegisterMap map;
return map;
}
}
<|fim_middle|> <Common/register_objects.h>
names<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string_view>
#incl<|fim_suffix|>actory;
using FunctionRegisterFunctionPtr = void (*)(::DB::FunctionFactory &);
struct FunctionRegisterMap : public std::unordered_map<std::string_view, FunctionRegisterFunctionPtr>
{
static FunctionRegisterMap & instance();
};
struct FunctionR... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nterpret_cast<void(*)(void*, size_t, void*)>(reinterpret_cast<intptr_t>(remapToHugeStep2) + offset)(begin, size, scratch);
}
}
size_t remapExecutable()
{
auto [begin, size] = getMappedArea(reinterpret_cast<void *>(remapExecutable));
remapToHugeStep1(begin, size);
return size;
}
}
#else
n... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>n size of remapped area.
size_t remapExecutable();
}
<|fim_prefix|>#pragma once
#inclu<|fim_middle|>de <cstdlib>
namespace DB
{
/// This function tries to reallocate the code of the running program in a more efficient way.
/// @retur<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
<|fim_suffix|>xpr (!std::is_signed_v<From> && std::is_signed_v<To> &&
std::numeric_limits<To>::digits > std::numeric_limits<From>::digits)
{
return static_cast<To>(value);
}
if (!std::in_range<To>(value))
throw Exception(ErrorCodes::LOGICAL_ERROR, "Numeri... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <base/scope_guard.h>
#include <Common/LockMemoryExceptionInThread.h>
/// Same as SCO<|fim_suffix|>mally
/// instead of ignoring write error).
///
/// NOTE: it should be used with double caution.
#define SCOPE_EXIT_SAFE(...) SCOPE_EXIT( \
try ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>(std::string_view{tmp_thread_name});
}
}
<|fim_prefix|>#include <string_view>
#include <unordered_map>
#include "config.h"
#include <pthread.h>
#if defined(OS_DARWIN) || defined(OS_SUNOS)
#elif defined(OS_FREEBSD)
#include <pthread_np.h>
#else
#include <sys/prctl.h>
#endif
#include <cstring>
#include... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string_view>
namespace DB
{
#define THREAD_NAME_VALUES(M)\
M(AGGREGATED_ZOOKEEPER_LOG, "AggrZooLog") \
M(AGGREGATOR_DESTRUCTION, "AggregDestruct") \
M(AGGREGATOR_POOL, "AggregatorPool") \
M(ARROW_FILE, "ArrowFile") \
M(ARROW_FLIGHT, "ArrowFlight") \
M(ARRO... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <string>
#include <string_view>
namespace DB
{
/// POSIX-compl<|fim_suffix|>.reserve(s.size() + 2);
out.push_back('\'');
for (char c : s)
{
if (c == '\'')
out.append("'\\''");
else
out.push_back(c);
}
out.push_back('\'')... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>= d(rng, param_t(i, n - 1));
swap(first[i], first[j]);
}
}
<|fim_prefix|>#pragma once
#include <iterator>
#include <random>
#include <utility>
/* Reorders the elements in the given range [first, last) such that each
* possible permutation of those elements has equal probability of appearanc... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ndTimeRange,
::testing::Combine(
::testing::ValuesIn(allTimezones(false)),
::testing::ValuesIn(std::initializer_list<TimeRangeParam>{
// Values from tests/date_lut3.cpp
{YYYYMMDDToDay(20100101), YYYYMMDDToDay(20101231), 10 * 3191 /*53m 11s*/},
}))
);
IN... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>r1 - unlocked
EXPECT_TRUE(blocker2.isCancelled());
EXPECT_FALSE(blocker1.isCancelled());
}
// automatically un-cancelled on `lock` destruction
EXPECT_FALSE(blocker1.isCancelled());
EXPECT_FALSE(blocker2.isCancelled());
EXPECT_EQ(0, blocker1.getCounter().load());
EX... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/AggregatedMetrics.h>
#include <gtest/gtest.h>
namespace CurrentMetrics
{
extern const Metric Query;
extern const Metric SharedMergeTreeMaxReplicas;
extern const Metric SharedMergeTreeMinReplicas;
}
TEST(AggregatedMetrics, GlobalSumSingleHandle)
{
auto handle = std::make... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#if !defined(SANITIZER)
#include <gtest/gtest.h>
#include <Common/CurrentMemoryTracker.h>
#include <Common/CurrentThread.h>
#inc<|fim_suffix|>rent(prev_parent);
});
thread_tracker.setParent(&query_tracker);
reset_test_counters();
query_tracker.setHardLimit(query_tracker.get() + 1024);... | fim | ClickHouse/ClickHouse | cpp |
#include <boost/core/noncopyable.hpp>
#include <gtest/gtest.h>
#include <array>
#include <atomic>
#include <exception>
#include <list>
#include <barrier>
#include <chrono>
#include <mutex>
#include <shared_mutex>
#include <stdexcept>
#include <string_view>
#include <vector>
#include <thread>
#include <pcg_random.hpp>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Common/Stopwatch.h>
#include <limits>
/// Calling these methods with values whose `seconds * 1e9` overflows `UInt64` used to
/// trigger UBSan (`runtime error: ... is outside the range of representabl<|fim_suffix|>cept
/// any finite non-negative `seconds` without UB... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/Base32.h>
#include <string_view>
#include <gtest/gtest.h>
using namespace std::string_view_literals;
namespace DB
{
static std::string to_hex(const UInt8 * data, size_t length)
{
static constexpr char hex_chars[] = "0123456789ABCDEF";
std::string result;
result.reserve(le... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>" << v.id;
EXPECT_EQ(*result, 64u) << "id=" << v.id;
EXPECT_EQ(0, memcmp(decoded, v.decoded.data(), 64)) << "id=" << v.id;
}
}
#if defined(__AVX2__)
TEST(Base58, Avx32)
{
for (const auto & v : test_data_32)
EXPECT_EQ(avxEncode32(v.decoded), scalarEncode32(v.decoded)) << "... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>hField)
{
const JSON json = JSON(std::string_view(R"({"k1":1,"k2":{"k3":2,"k4":3,"k":4},"k":5})"));
ASSERT_EQ(json["k1"].getUInt(), 1);
ASSERT_EQ(json["k2"].toString(), R"({"k3":2,"k4":3,"k":4})");
ASSERT_EQ(json["k2"]["k3"].getUInt(), 2);
ASSERT_EQ(json["k2"]["k4"].getUInt(), 3);
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>should be in good state after flush";
ASSERT_EQ(buf.written(), data);
/// 13 bytes with max 3 per call = at least 5 writeToDevice calls
ASSERT_GE(buf.writeCount(), 5);
}
TEST(BufferedStreamBuf, FlushHandlesShortWritesSingleByte)
{
/// Worst case: device writes 1 byte at a time.
Short... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> reclaimable categories at all: nothing to discount.
{
std::string content = R"(anon 5000000000
sock 1000
)";
ReadBufferFromString buf(content);
ASSERT_EQ(reclaimableFromCgroupV2Stat(buf), 0ull);
}
}
#endif
<|fim_prefix|>#if defined(OS_LINUX)
#include <gtest/gtest.h>
#in... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> (must be >3)
ConcurrencyControlTest t(cfg_max_concurrency);
auto run_query = [&] (size_t max_threads)
{
SlotAllocationPtr slots = t.cc.allocate(1, max_threads);
std::mutex threads_mutex;
std::vector<std::thread> threads;
threads.reserve(max_threads);
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/Config/ConfigHelper.h>
#include <Poco/AutoPtr.h>
#include <Poco/Util/XMLConfiguration.h>
#include <Poco/DOM/DOMParser.h>
#include <gtest/gtest.h>
using namespace DB;
TEST(Common, ConfigWithDo<|fim_suffix|>String(xml);
Poco::AutoPtr<Poco::Util::XMLConfiguration> config = new Poco::... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/Config/ConfigHelper.h>
#include <Poco/AutoPtr.h>
#include <Poco/Util/XMLConfiguration.h>
#include <Poco/DOM/D<|fim_suffix|>;
EXPECT_EQ(ConfigHelper::getBool(*config, "empty_as_true_1", false, true), true);
EXPECT_EQ(ConfigHelper::getBool(*config, "empty_as_true_2", false, true), t... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Poco/AutoPtr.h>
#include <Poco/DOM/DOMParser.h>
#include <Poco/Util/XMLConfiguration.h>
#include <gtest/gtest.h>
TEST(Common, ConfigHostValidation)
{
std::string xml(R"CONFIG(<clickhouse>
<IPv4_1>0.0.0.0</IPv4_1>
<IPv4_2>192.168.0.1</IPv4_2>
<IPv4_3>127.0.0.1</IPv4_3>
<IPv4... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/Config/ConfigProcessor.h>
#include <IO/WriteBufferFromFile.h>
#include <IO/WriteHelpers.h>
#include <Poco/Timestamp.h>
#include <Poco/Util/XMLConfiguration.h>
#include <base/scope_guard.h>
#include <gtest/gtest.h>
#include <filesystem>
TEST(Common, ConfigProcessorManyElements)
{
nam... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>eturn "http://" + server_data.server->socket().address().toString();
}
void startServer()
{
server_data.reset();
server_data.handler_factory = new HTTPRequestHandlerFactory(options);
server_data.server = std::make_unique<Poco::Net::HTTPServer>(
server_data... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Common/DNSResolver.h>
#include <Poco/Net/IPAddress.h>
#include <random>
namespace DB
{
TEST(Common, ReverseDNS)
{
auto func = [&]()
{
// Good random seed, good engine
auto rnd1 = std::mt19937(std::random_device{}());
for (int i = 0; i < 10; ++i)
{
auto... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
auto handler11 = EventNotifier::instance().subscribe(Coordination::Error::ZSESSIONEXPIRED, [&result](){ result *= 11; });
result = 1;
handler7.reset();
EventNotifier::instance().notify(Coordination::Error::ZSESSIONEXPIRED);
ASSERT_EQ(result, 11);
EventNotifier::HandlerPtr handl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Common/EventRateMeter.h>
#include <cmath>
TEST(EventRateMeter, ExponentiallySmoothedAverage)
{
double target = 100.0;
// The test is only correct for timestep of 1 second because of
// how sum of weights is implemented inside `ExponentiallySmoothedAverag... | fim | ClickHouse/ClickHouse | cpp |
#include <gtest/gtest.h>
#include <Core/Field.h>
#include <Common/FieldAccurateComparison.h>
using namespace DB;
/// Test Decimal vs Float64 comparison
TEST(FieldAccurateComparisonTest, DecimalVsFloat64)
{
/// 44.40 as Decimal64 vs Float64
Field decimal_44_40 = DecimalField<Decimal64>(4440, 2);
Field floa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_or_null(haystack, SearchSymbols("0")), haystack), 0);
// Match inside the SIMD chunk, not in the prologue.
EXPECT_EQ(offset(find_last_symbols_or_null(haystack, SearchSymbols("5")), haystack), 5);
}
// \0 byte in the haystack: a runtime needle of "\0" must find it; an unrelated
... | fim | ClickHouse/ClickHouse | cpp |
#include <gtest/gtest.h>
#include <Common/FloatUtils.h>
#include <fmt/format.h>
#include <bit>
#include <cmath>
#include <cstdint>
namespace
{
uint32_t asBits(float x)
{
return std::bit_cast<uint32_t>(x);
}
float fromBits(uint32_t bits)
{
return std::bit_cast<float>(bits);
}
::testing::AssertionResult as... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tion);
EXPECT_THROW(routine("[:do_not_exis..."), DB::Exception);
EXPECT_THROW(routine("^abc"), DB::Exception);
}
TEST(GenerateRandomString, DifferentResult)
{
std::cerr << "100 different keys" << std::endl;
auto gen = DB::RandomStringGeneratorByRegexp("prefix-[a-z]{3}-suffix/[0-9a-f]{20}"... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/getMultipleKeysFromConfig.h>
#include <Poco/AutoPtr.h>
#include <Poco/Util/XMLConfiguration.h>
#include <gtest/gtest.h>
using namespace DB;
TEST(Common, getMultipleValuesFromConfig)
{
std<|fim_suffix|> xml_isteam(R"END(<clickhouse>
<first_level>
<second_level>0</seco... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <atomic>
#include <thread>
#include <unordered_set>
#include <vector>
#include <Common/GetPriorityForLoadBalancing.h>
using namespace DB;
namespace
{
/// For a closure produced by `getPriorityFunc(ROUND_ROBIN, 0, pool_size)` find the index
/// `i` such that `f... | fim | ClickHouse/ClickHouse | cpp |
#include <Common/tests/gtest_global_context.h>
#include <Core/Settings.h>
namespace DB::Setting
{
extern const SettingsString local_filesystem_read_method;
}
ContextHolder::ContextHolder()
: shared_context(DB::Context::createShared())
, context(DB::Context::createGlobal(shared_context.get()))
{
context->... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/Context.h>
struct Con<|fim_suffix|> context->shutdown();
context.reset();
shared_context.reset();
}
};
struct TestCommandLineOptions
{
int argc = 0;
const char * const * argv = nullptr;
};
const ContextHolder & getContext();
ContextHol... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Functions/registerFunctions.h>
#include <AggregateFunctions/registerAggregateFunctions.h>
#include <Formats/registerFormats.h>
inline void tryRegisterAggregateFunctions()
{
static struct Register { Register() { DB::registerAggregateFunctions(); } } registered;
}
inline void t... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> : public ::testing::TestWithParam<HashSetContent>
{
};
TEST_P(TwoLevelHashSetFixture, WriteAsSingleLevel)
{
using Key = UInt64;
{
const auto & hash_set_content = GetParam();
TwoLevelHashSet<Key, HashCRC32<Key>> two_level;
for (const auto & elem : hash_set_content)
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <filesystem>
#include <Common/filesystemHelpers.h>
#incl<|fim_suffix|>uto *attributes = pNode->attributes();
for (auto i = 0; i<attributes->length();i++)
{
auto *item = attributes->item(i);
auto name = item->nodeName();
auto text = item->innerText();... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <gtest/gtest.h>
#include <vector>
#include <base/types.h>
#include <Common/HilbertUtils.h>
/// The bit-shift in `segmentBinaryPartition` at `HilbertUtils.h:78` used the
/// literal `1` which is a 32-bit `int`. When `next_bits >= 32`, the shift
/// `1 << next_bits` invoked undefined behaviour ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> EXPECT_EQ(metric.getCounter(1), 3);
}
/// (10, +Inf) bucket is the last one
TEST(HistogramMetricsTest, ObserveAboveAllBuckets)
{
metric.observe(1000);
EXPECT_EQ(metric.getCounter(test_buckets.size()), 1);
}
<|fim_prefix|>#include <gtest/gtest.h>
#include <Common/HistogramMetrics.h>
using nam... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Poco/Net/HTTPChunkedStream.h>
#include <Poco/Net/HTTPClientSession.h>
TEST(HTTPChunkedStreamBuf, IsCompleteHandlesInvalidSocketException)
{
Poco::Net::HTTPClientSession session;
Poco::Net::HTTPChunkedStreamBuf buf(session, std::ios::in);
/// Default-in<|f... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Socket server_socket;
};
}
/// Writing exactly Content-Length bytes should succeed.
TEST(HTTPFixedLengthStreamBuf, WriteExactLength)
{
PassiveListener listener;
Poco::Net::HTTPClientSession session(listener.connect());
Poco::Net::HTTPFixedLengthOutputStream stream(session, 10);
stream... | fim | ClickHouse/ClickHouse | cpp |
#include <gtest/gtest.h>
#include <set>
#include <map>
#include <base/types.h>
#include <Common/IntervalTree.h>
using namespace DB;
using Int64Interval = Interval<Int64>;
template <typename IntervalType>
std::set<IntervalType> intervalSetToSet(const IntervalSet<IntervalType> & interval_set)
{
std::set<Interval... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>m #102183. Before the fix this aborted in debug builds and
/// emitted a spurious `Jemalloc settings mismatch` warning otherwise.
TEST(Jemalloc, VerifySetupNoAbortWhenBackgroundThreadMallctlMissing)
{
bool current_background_thread = false;
const bool background_thread_supported
= Jemalloc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <thread>
#include <vector>
#include <atomic>
#include <Poco/AutoPtr.h>
#include <Poco/Util/LayeredConfiguration.h>
#include <Poco/Util/MapConfiguration.h>
using Poco::AutoPtr;
using Poco::Util::LayeredConfiguration;
using Poco::Util::MapConfiguration;
static AutoPtr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>CT_TRUE(DB::isLocalAddress(address));
}
TEST(LocalAddress, Localhost)
{
EXPECT_TRUE(DB::isLocalAddress(Poco::Net::IPAddress{"127.0.0.1"}));
EXPECT_TRUE(DB::isLocalAddress(Poco::Net::IPAddress{"127.0.1.1"}));
EXPECT_TRUE(DB::isLocalAddress(Poco::Net::IPAddress{"127.1.1.1"}));
EXPECT_TRUE(D... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
checkComparison();
}
<|fim_prefix|>#include <i<|fim_middle|>ostream>
#include <stdexcept>
#include <gtest/gtest.h>
#include <Common/LocalDateTime.h>
static void fillStackWithGarbage()
{
volatile uint64_t a = 0xAABBCCDDEEFF0011ULL;
volatile uint64_t b = 0x2233445566778899ULL;
std::cout ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>td::vector<std::string> names;
Poco::Logger::names(names);
size_t loggers_size_before = names.size();
std::vector<std::thread> threads;
threads.reserve(threads_count);
for (size_t thread_index = 0; thread_index < threads_count; ++thread_index)
{
threads.emplace_back([]()... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <iomanip>
#include <gtest/gtest.h>
#include <Common/CacheBase.h>
#include <Common/CurrentMetrics.h>
/// Use MarkCache* for tests (to avoid introducing one more metric)
namespace CurrentMetrics
{
extern const Metric MarkCacheBytes;
extern const Metric MarkCacheFiles;
}
TEST(LRUCache, set... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_TRUE(holder1->value() == 11);
}
<|fim_prefix|>#include <iomanip>
#include <gtest/gtest.h>
#include <Common/LRUResourceCache.h>
TEST(LRUResourceCache, get)
{
using MyCache = DB::LRUResourceCache<int, int>;
auto mcache = MyCache(10, 10);
int x = 10;
auto load_int = [&] { return std::make_... | fim | ClickHouse/ClickHouse | cpp |
#include <base/defines.h> // ADDRESS_SANITIZER
#ifdef ADDRESS_SANITIZER
#include <cstdlib>
#include <thread>
#include <gtest/gtest.h>
#include <sanitizer/lsan_interface.h>
/// Test that ensures that LSan works.
///
/// Regression test for the case when it may not work,
/// because of broken getauxval() [1].
///
///... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ommandLineOptions();
options.argc = argc;
options.argv = argv;
testing::AddGlobalTestEnvironment(new ContextEnvironment);
return RUN_ALL_TESTS();
}
<|fim_prefix|>#include <gtest/gtest.h>
#include <base/sanitizer_options.h>
#include <Common/tests/gtest_global_context.h>
class ContextEn... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>lobs("f{01..9}"), "f(01|02|03|04|05|06|07|08|09)");
EXPECT_EQ(makeRegexpPatternFromGlobs("f{000..9}"), "f(000|001|002|003|004|005|006|007|008|009)");
EXPECT_EQ(makeRegexpPatternFromGlobs("f{95..103}"), "f(95|96|97|98|99|100|101|102|103)");
EXPECT_EQ(makeRegexpPatternFromGlobs("f{99..109}"), "f... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>}
<|fim_prefix|>#include <gtest/gtest.h>
#include <filesystem>
#include <base/scope_guard.h>
#include <Common/filesystemHelpers.h>
#include <IO/WriteBufferFromFile.h>
#include <IO/WriteHelpers.h>
#include <Common/Config/ConfigProcessor.h>
#include <Poco/Util/XMLConfiguration.h>
TEST(Config, MergeConfi... | fim | ClickHouse/ClickHouse | cpp |
#include <gtest/gtest.h>
#include <iostream>
#include <Common/MortonUtils.h>
GTEST_TEST(MortonUtils, Intervals)
{
{
std::stringstream res;
intervalBinaryPartition(6, 13, [&](UInt64 first, UInt64 last)
{
res << first << ", " << last << "; ";
});
ASSERT_EQ(res.str... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/tests/gtest_global_context.h>
#include <Common/NamedCollections/NamedCollectionsFactory.h>
#include <Poco/Util/XMLConfiguration.h>
#include <Poco/DOM/DOMParser.h>
#include <gtest/gtest.h>
using namespace DB;
/// A class which allows to test private methods of NamedCollectionFactory.
cla... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.