text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>O/SnappyReadBuffer.h>
#include <IO/WriteHelpers.h>
#include <IO/copyData.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/WriteBufferFromString.h>
#include <Examples/clickhouse_examples.h>
int mainEntryExampleSnappyReadBuffer(int, char **)
{
using namespace DB;
String str = "this is a snappy e... | fim | ClickHouse/ClickHouse | cpp |
#include <IO/WriteBufferValidUTF8.h>
#include <IO/WriteBufferFromString.h>
#include <IO/WriteHelpers.h>
#include <string>
#include <iostream>
#include <Examples/clickhouse_examples.h>
int mainEntryExampleValidUtf8(int, char **)
{
try
{
std::string test1 = R"(kjhsgdfkjhg2378rtzgvxkz877%^&^*%&^*&*)";
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <IO/WriteBufferValidUTF8.h>
#include <IO/WriteBufferFromString.h>
#include <Common/Stopwatch.h>
#include <string>
#include <iostream>
#include <Examples/clickhouse_examples.h>
int mainEntryExampleValidUtf8Perf(int argc, char ** argv)
{
try
{
int repeats = 1;
if (argc >= 2... | fim | ClickHouse/ClickHouse | cpp |
#include <string>
#include <iostream>
#include <sstream>
#include <base/types.h>
#include <IO/WriteHelpers.h>
#include <IO/WriteBufferFromOStream.h>
#include <Examples/clickhouse_examples.h>
int mainEntryExampleWriteBuffer(int, char **)
{
try
{
Int64 a = -123456;
Float64 b = 123.456;
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <string>
#include <iostream>
#include <fstream>
#include <base/types.h>
#include <IO/WriteHelpers.h>
#include <IO/WriteBufferFromOStream.h>
#include <Examples/clickhouse_examples.h>
int mainEntryExampleWriteBufferPerf(int, char **)
{
try
{
Int64 a = -123456;
Float64 b ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <IO/WriteHelpers.h>
#include <IO/WriteBufferFromFileDescriptor.h>
#include <Examples/clickh<|fim_suffix|> DB;
static void NO_INLINE write(WriteBuffer & out, size_t size)
{
for (size_t i = 0; i < size; ++i)
{
writeIntText(i, out);
writeChar(' ', out);
}
}
int mainEnt... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>;
}
{
auto buf = std::make_unique<DB::ReadBufferFromFile>("test_zlib_buffers.gz");
DB::ZlibInflatingReadBuffer inflating_buf(std::move(buf), DB::CompressionMethod::Gzip);
stopwatch.restart();
for (size_t i = 0; i < n; ++i)
{
size_t x = {};
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <unistd.h>
#include <stdexcept>
#include <zlib.h>
#include <Examples/clickhouse_examples.h>
#include <Common/VectorWithMemoryTracking.h>
/// https://g<|fim_suffix|>n_size = read(STDIN_FILENO, in.data(), 1048576);
if (in_size < 0)
throw std::runtime_error("Cannot read");
in.resi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>len(argv[1]) && errno != ERANGE && uint_value <= ZSTD_maxCLevel() && uint_value >= ZSTD_minCLevel())
compression_level = uint_value;
else
throw DB::Exception(
DB::ErrorCodes::BAD_ARGUMENTS,
"Wrong compression level: '{}'. Expected an integer ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Common/DateLUTImpl.h>
#include <Common/StringUtils.h>
#include <base/arithmeticOverflow.h>
#include <IO/ReadBuffer.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <IO/parseDateTimeBestEffort.h>
#include <cstring>
#include <limits>
namespace DB
{
namespace ErrorCodes
{
ex... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> inference if date times.
bool tryParseDateTimeBestEffortStrict(time_t & res, ReadBuffer & in, const DateLUTImpl & local_time_zone, const DateLUTImpl & utc_time_zone, const char * allowed_date_delimiters);
bool tryParseDateTimeBestEffortUSStrict(time_t & res, ReadBuffer & in, const DateLUTImpl & local_tim... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> with scale {} and precision {}",
digits, convertFieldToString(x), exponent, scale, precision);
}
else
return ReturnType(false);
}
if (static_cast<int32_t>(scale) + exponent < 0)
{
auto divisor_exp = -exponent - static_cast<int32_t>(scale);
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>at16 &, ReadBuffer &);
template bool tryReadFloatTextNoExponent<Float32>(Float32 &, ReadBuffer &);
template bool tryReadFloatTextNoExponent<Float64>(Float64 &, ReadBuffer &);
}
<|fim_prefix|>#include <IO/readFloatText.h>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_PARSE_INPUT_ASSE... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>loat16(tmp);
}
else
readFloatTextPreciseImpl<T, void>(x, in);
}
template <typename T> bool tryReadFloatTextPrecise(T & x, ReadBuffer & in)
{
if constexpr (std::is_same_v<T, BFloat16>)
{
Float32 tmp = 0;
bool res = readFloatTextPreciseImpl<Float32, bool>(tmp, in);
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>]
return on_error();
}
if (*buf.position() == '0') /// There are many zeros in real datasets.
{
++buf.position();
x = 0;
return ReturnType(true);
}
while (!buf.eof())
{
unsigned char value = *buf.position() - '0';
if (value < 1... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <gtest/gtest.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <IO/parseDateTimeBestEffort.h>
#include <Common/PODArray.h>
/** Test formatting and parsing predefined DateTime64 values to/from string
*/
using namespace DB;
struct DateTime64StringsTestParam
{
const std:... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Common/DateLUT.h>
#include <IO/WriteHelpers.h>
#include <IO/WriteBufferFromString.h>
namespace
{
using namespace DB;
struct DateTime64WithScale
{
DateTime64 value;
UInt32 scale;
};
template <typename ValueType>
auto getTypeName(const ValueType &)
{
if con... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <string>
#include <vector>
#include <IO/WriteHelpers.h>
using namespace DB;
TEST(WriteHelpersTest, ToStringWithFinalSeparatorTest)
{
{
std::vec<|fim_suffix|>toStringWithFinalSeparator(v, " or "), "'AAA', 'BBB' or 'CCC'");
}
{
std::vector<st... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include "config.h"
#include <filesystem>
#include <IO/Archives/ArchiveUtils.h>
#include <IO/Archives/IArchiveReader.h>
#include <IO/Archives/IArchiveWriter.h>
#include <IO/Archives/createArchiveReader.h>
#include <IO/Archives/createArchiveWriter.h>
#include <IO/ReadBufferFromFi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> {32, BIT_PATTERN}, {12, 0xff}, {8, 0}, {12, 0xAEff}},
"11101011 11101111 10111010 11101111 10101111 10111010 11101011 10101001 " // 64
"11101111 10111010 11101111 10101111 10111010 11101011 10101001 11111000 " // 128
"11111111 11101011 11101111 10111010 11101111 101011... | fim | ClickHouse/ClickHouse | cpp |
#include "config.h"
#if USE_SSL
#include <gtest/gtest.h>
#include <IO/WriteBufferFromString.h>
#include <IO/FileEncryptionCommon.h>
#include <IO/WriteBufferFromFile.h>
#include <IO/WriteBufferFromEncryptedFile.h>
#include <IO/ReadBufferFromEncryptedFile.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/ReadHelpers.h>... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <snappy.h>
#include <IO/HadoopSnappyReadBuffer.h>
#include <gtest/gtest.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/ReadBufferFromString.h>
#include <IO/WriteBufferFromFile.h>
#include <IO/WriteBufferFromString.h>
#include <IO/WriteHelpers.h>
#include <IO/copyData.h>
#include <Poco/Base64... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <IO/EmptyReadBuffer.h>
#include <IO/LimitSeekableReadBuffer.h>
#include <IO/ReadBufferFromMemory.h>
#include <IO/ReadHelpers.h>
using namespace DB;
/// Regression test for UBSAN finding STID 3079-3df0:
/// src/IO/LimitSeekableReadBuffer.cpp:97:34:
/// runtime error... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <IO/IFileBasedSourceReader.h>
#include <IO/LocalSourceReader.h>
#include <IO/ReadBufferFromFileBase.h>
#include <Disks/DiskObjectStorage/ObjectStorages/StoredObject.h>
#include <gtest/gtest.h>
#include <fstream>
#include <file<|fim_suffix|>buf = reader.open(obj);
ASSERT_TRUE(buf);
std::... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>, binary)
{
checkString("Hello", binary, "\x5Hello");
std::string s1 = "Hello";
checkString(s1, binary, "\x5Hello");
std::string_view sv1 = s1;
checkString(sv1, binary, "\x5Hello");
std::string_view sr1 = s1;
checkString(sr1, binary, "\x5Hello");
}
<|fim_prefix|>#include <gt... | fim | ClickHouse/ClickHouse | cpp |
#include <IO/WriteHelpers.h>
#include <IO/ReadHelpers.h>
#include <IO/BufferWithOwnMemory.h>
#include <gtest/gtest.h>
#include <Common/ErrnoException.h>
#define EXPECT_THROW_ERROR_CODE(statement, expected_exception, expected_code) \
EXPECT_THROW( \
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>_buffers.emplace_back(std::make_unique<ReadBufferFromMemory>(memory_buffers_data.back()->data(), bad_buffer_size));
}
ConcatReadBuffer concat_buffer(std::move(nested_buffers));
MySQLBinlogEventReadBuffer binlog_in(concat_buffer, 4);
binlog_in.readStrict(res, 12);
for (const auto & re... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <IO/OffsetMap.h>
#include <gtest/gtest.h>
using namespace DB;
TEST(OffsetMap, SingleObject)
{
StoredObjects objects;
objects.emplace_back("obj_a", "", 1000);
OffsetMap map;
map.build(objects);
EXPECT_EQ(map.totalSize(), 1000u);
EXPECT_FALSE(map.hasUnknownSize());
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <base/types.h>
#include <IO/ReadHelpers.h>
#include <IO/ReadBufferFromString.h>
#include <IO/ConcatReadBuffer.h>
#include <IO/PeekableReadBuffer.h>
static void readAndAssert(DB::ReadBuffer & buf, const char * str)
{
size_t n = strlen(str);
std::vector<char> tmp(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>28, 200)
buf->setReadUntilEnd();
std::vector<char> rest;
while (true)
{
char tmp[256];
size_t got = buf->read(tmp, sizeof(tmp));
if (got == 0)
break;
rest.insert(rest.end(), tmp, tmp + got);
}
ASSERT_EQ(rest.size(), 1024u - 200u); ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <base/types.h>
#include <Common/filesystemHelpers.h>
#include <IO/WriteBufferFromFile.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/AsynchronousReadBufferFromFile.h>
#include <IO/SynchronousReader.h>
#include <IO/WriteHelpers.h>
#include <IO/ReadHelpers.h>
using na... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>XPECT_EQ((getErrorOfParseIntInBase<8, int>("Ab01")), ErrorCodes::CANNOT_PARSE_INPUT_ASSERTION_FAILED);
EXPECT_EQ((getErrorOfParseIntInBase<10, int>("Ab01")), ErrorCodes::CANNOT_PARSE_INPUT_ASSERTION_FAILED);
EXPECT_EQ((parseIntInBase<16, int>("Ab01")), 43777);
}
<|fim_prefix|>#include <gtest/gtest... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <IO/ReadPipeline.h>
#include <IO/ReadBufferFromFileBase.h>
#include <IO/ReadHelpers.h>
#include <cstring>
#include <map>
using namespace DB;
namespace
{
/// A ReadBufferFromFileBase that reads from a string, chunk by chunk in nextImpl.
/// Compatible with the ReadBu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <IO/ReadPipeline.h>
#include <IO/PipelineReadBuffer.h>
#include <IO/ReadSettings.h>
#include <IO/ReadBufferFromFileBase.h>
#include <Disks/DiskObjectStorage/ObjectStorages/Local/LocalObjectStorage.h>
#include <Disks/DiskObjectStorage/ObjectStorages/StoredObject.h>
#incl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nd();
async_buf->prefetch(Priority{0});
async_buf->seek(16, SEEK_SET);
ASSERT_EQ(async_buf->available(), 0);
async_buf->prefetch(Priority{0});
async_buf->next();
ASSERT_EQ(async_buf->available(), 4);
async_buf->position() = async_buf->buffer().end();
async_buf->prefetch(Pri... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <IO/ReaderExecutor.h>
#include <IO/LocalSourceReader.h>
#include <Disks/DiskObjectStorage/ObjectStorages/StoredObject.h>
#include <Common/CurrentThread.h>
#include <Common/ProfileEvents.h>
#include <Common/ThreadGroupSwitcher.h>
#include <Common/ThreadStatus.h>
#include <Common/setThreadName.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include "config.h"
#if USE_AWS_S3
#include <IO/S3Common.h>
namespace
{
using namespace DB;
struct TestCase
{
S3::URI uri;
String endpoint;
String bucket;
String key;
String version_id;
bool is_virtual_hosted_style;
};
const TestCase TestCases[] = {
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> WriteBufferFromFile out(tmp_file->path());
for (size_t i = 0; i < N; ++i)
writeIntBinary(i, out);
out.finalize();
}
ReadBufferFromFile in(tmp_file->path(), BUF_SIZE);
size_t x = {};
/// Read something to initialize the buffer.
in.seek(BUF_SIZE * 10, S... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> ss.write(payload.data(), payload.size());
}
<|fim_prefix|>#include <gtest/gtest.h>
#include <sstream>
#include <string>
// There are few places where stringstream is used to pass data to some 3d
// party code.
//
// And there was problems with feeding > INT_MAX to stringstream in libc++,
// this is t... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>u_2");
buffer->write('A');
getAsyncPolicy().setAutoExecute(true);
buffer->finalize();
}
catch( const DB::Exception& e )
{
ASSERT_EQ(ErrorCodes::S3_ERROR, e.code());
EXPECT_THAT(e.what(), testing::HasSubstr("CreateMPUFailI... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Interpreters/Access/InterpreterCheckGrantQuery.h>
#include <Access/ContextAccess.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypesNumber.h>
#include <Interpreters/Context.h>
#include <Interpreters/InterpreterFactory.h>
#include <Parsers/Access/ASTCheckGrantQuery.h>
#include <P... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>s/IInterpreter.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
class InterpreterCheckGrantQuery : public IInterpreter, WithMutableContext
{
public:
InterpreterCheckGrantQuery(const ASTPtr & query_ptr_, ContextMutablePtr context_) : WithMutableContext(context_), query_ptr(query_ptr_) {}
BlockIO... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>House Cloud");
}
void registerInterpreterCreateMaskingPolicyQuery(InterpreterFactory & factory);
void registerInterpreterCreateMaskingPolicyQuery(InterpreterFactory & factory)
{
auto create_fn = [] (const InterpreterFactory::Arguments & args)
{
return std::make_unique<InterpreterCreateMas... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/IInterpreter.h>
#include <Parsers/IAST_fwd.h>
namespace <|fim_suffix|>lockIO execute() override;
private:
ASTPtr query_ptr;
};
}
<|fim_middle|>DB
{
class ASTCreateMaskingPolicyQuery;
class AccessRightsElements;
struct MaskingPolicy;
class InterpreterCreateMask... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>cessEntityPtr
{
auto updated_quota = typeid_cast<std::shared_ptr<Quota>>(entity->clone());
updateQuotaFromQueryImpl(*updated_quota, query, {}, roles_from_query);
return updated_quota;
};
if (query.if_exists)
{
auto ids = stora... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tableContext(context_), query_ptr(query_ptr_) {}
BlockIO execute() override;
bool ignoreQuota() const override { return true; }
bool ignoreLimits() const override { return true; }
static void updateQuotaFromQuery(Quota & quota, const ASTCreateQuotaQuery & query);
private:
ASTPtr qu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>another_storage_ptr->getStorageName());
}
}
if (query.if_not_exists)
storage->tryInsert(new_roles);
else if (query.or_replace)
storage->insertOrReplace(new_roles);
else
storage->insert(new_roles);
}
return {};
}
vo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/IInterpreter.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
class ASTCreateRoleQuery;
struct R<|fim_suffix|>eterCreateRoleQuery : public IInterpreter, WithMutableContext
{
public:
InterpreterCreateRoleQuery(const ASTPtr & query_ptr_, ContextMutablePtr context_)... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ry)
{
auto create_fn = [] (const InterpreterFactory::Arguments & args)
{
return std::make_unique<InterpreterCreateRowPolicyQuery>(args.query, args.context);
};
factory.registerInterpreter("InterpreterCreateRowPolicyQuery", create_fn);
}
}
<|fim_prefix|>#include <Interpreters/Inter... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Interpreters/IInterpreter.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
class ASTCreateRowPolicyQuery;
class AccessRightsElements;
struct RowPolicy;
class InterpreterCreateRowPolicyQuery : public IInterpreter, WithMutableContext
{
public:
InterpreterCreateRowPolicyQuery(const ASTPtr & q... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/InterpreterFactory.h>
#include <Interpreters/Access/InterpreterCreateSettingsProfileQuery.h>
#include <Access/AccessControl.h>
#include <Access/Common/AccessFlags.h>
#include <Access/SettingsProfile.h>
#include <Interpreters/Context.h>
#include <Interpreters/executeDDLQueryOnCluste... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/IInterpreter.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
class ASTCreateSettingsProfileQuery;
struct SettingsProfile;
class InterpreterCreateSettingsProfileQuery : public IInterpreter, WithMutableContext
{
public:
InterpreterCreateSettin<|fim_suffix|> AS... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/InterpreterFactory.h>
#include <Interpreters/Access/InterpreterCreateUserQuery.h>
#include <Access/AccessControl.h>
#include <Access/ContextAccess.h>
#include <Access/ReplicatedAccessStorage.h>
#include <Access/User.h>
#include <Common/logger_useful.h>
#include <Core/ServerSettings... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/IInterpreter.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
class ASTCreateUserQuery;
struct User;
class InterpreterCreateUserQuery : public IInterpreter, WithMutableContext
{
public:
InterpreterCreateUserQuery(const ASTPtr & query_ptr_, ContextMutablePtr cont... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ate_fn);
}
}
<|fim_prefix|>#include <Interpreters/Access/InterpreterDropAccessEntityQuery.h>
#include <Interpreters/InterpreterFactory.h>
#include <Access/AccessControl.h>
#include <Access/Common/AccessRightsElement.h>
#include <Access/MaskingPolicy.h>
#include <Access/ViewDefinerDependencies.h>
#includ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>InterpreterDropAccessEntityQuery(const ASTPtr & query_ptr_, ContextMutablePtr context_) : WithMutableContext(context_), query_ptr(query_ptr_) {}
BlockIO execute() override;
private:
AccessRightsElements getRequiredAccess() const;
ASTPtr query_ptr;
};
}
<|fim_prefix|>#pragma once
#include ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/Access/InterpreterExecuteAsQuery.h>
#include <Access/AccessControl.h>
#include <Access/User.h>
#include <Core/Settings.h>
#include <Parsers/Access/ASTExecuteAsQuery.h>
#include <Parsers/Access/ASTUserNameWithHost.h>
#include <Interpreters/Context.h>
#include <Interpreters/Interpret... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/IInterpreter.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
class InterpreterExecuteAsQuery : public IInterpreter, WithMutableContext
{
public:
Interpre<|fim_suffix|> ASTPtr query_ptr;
};
}
<|fim_middle|>terExecuteAsQuery(const ASTPtr & query_ptr_, ContextMu... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/InterpreterFactory.h>
#include <Interpreters/Access/InterpreterGrantQuery.h>
#include <Parsers/Access/ASTGrantQuery.h>
#include <Parsers/Access/ASTRolesOrUsersSet.h>
#include <Access/AccessControl.h>
#include <Access/ContextAccess.h>
#include <Access/Role.h>
#include <Access/RolesOr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/UUID.<|fim_suffix|> updateUserFromQuery(User & user, const ASTGrantQuery & query);
static void updateRoleFromQuery(Role & role, const ASTGrantQuery & query);
private:
ASTPtr query_ptr;
};
}
<|fim_middle|>h>
#include <Interpreters/IInterpreter.h>
#include <Parsers/IAS... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>t auto & query = query_ptr->as<const ASTMoveAccessEntityQuery &>();
AccessRightsElements res;
switch (query.type)
{
case AccessEntityType::USER:
{
for (const auto & name: query.names)
{
res.emplace_back(AccessType::DROP_USER, name);
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>espace DB
{
class AccessRightsElements;
class InterpreterMoveAccessEntityQuery : public IInterpreter, WithMutableContext
{
public:
InterpreterMoveAccessEntityQuery(const ASTPtr & query_ptr_, ContextMutablePtr context_) : WithMutableContext(context_), query_ptr(query_ptr_) {}
BlockIO execute() ov... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/InterpreterFactory.h>
#include <Interpreters/Access/InterpreterSetRoleQuery.h>
#include <Parsers/Access/ASTSetRoleQuery.h>
#include <Parsers/Access/ASTRolesOrUsersSet.h>
#include <Access/RolesOrUsersSet.h>
#include <Access/AccessControl.h>
#include <Access/User.h>
#include <Interpre... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>user, const RolesOrUsersSet & roles_from_query);
private:
void setRole(const ASTSetRoleQuery & query);
void setDefaultRole(const ASTSetRoleQuery & query);
ASTPtr query_ptr;
};
}
<|fim_prefix|>#pragma once
#include <Interpreters/IInterpreter.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ShowAccessEntitiesQuery(InterpreterFactory & factory);
void registerInterpreterShowAccessEntitiesQuery(InterpreterFactory & factory)
{
auto create_fn = [] (const InterpreterFactory::Arguments & args)
{
return std::make_unique<InterpreterShowAccessEntitiesQuery>(args.query, args.context);
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/IInterpreter.h>
#<|fim_suffix|> ASTPtr query_ptr;
};
}
<|fim_middle|>include <Parsers/IAST_fwd.h>
namespace DB
{
class InterpreterShowAccessEntitiesQuery : public IInterpreter, WithMutableContext
{
public:
InterpreterShowAccessEntitiesQuery(const ASTPtr & query... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/InterpreterFactory.h>
#include <Interpreters/Access/InterpreterShowAccessQuery.h>
#include <Interpreters/Context.h>
#include <Interpreters/Access/InterpreterShowCreateAccessEntityQuery.h>
#include <Interpreters/Access/InterpreterShowGrantsQuery.h>
#include <Interpreters/formatWithP... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/IInterpreter.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
struct IAccessEntity;
using AccessEntityPtr = std::shared_ptr<const IAccessEntity>;
/** Return all queries for creating access entities and grants.
*/
class InterpreterShowAccessQuery : public IInterpre... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>id registerInterpreterShowCreateAccessEntityQuery(InterpreterFactory & factory)
{
auto create_fn = [] (const InterpreterFactory::Arguments & args)
{
return std::make_unique<InterpreterShowCreateAccessEntityQuery>(args.query, args.context);
};
factory.registerInterpreter("Interprete... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/IInterpreter.h>
#include <Parsers/IAST_fwd.h>
#include <Core/UUID.h>
namespace DB
{
class AccessControl;
class Context;
class AccessRightsElements;
struct IAccessEntity;
using AccessEntityPtr = std::shared_ptr<const IAccessEntity>;
/** Returns a single item contain... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>riesImpl(user_or_role, &access_control, false, with_implicit, final);
}
ASTs InterpreterShowGrantsQuery::getAttachGrantQueries(const IAccessEntity & user_or_role)
{
return getGrantQueriesImpl(user_or_role, nullptr, true, false);
}
void registerInterpreterShowGrantsQuery(InterpreterFactory & factory... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ntQueries() const;
std::vector<AccessEntityPtr> getEntities() const;
ASTPtr query_ptr;
};
}
<|fim_prefix|>#pragma once
#include <Core/UUID.h>
#include <Interpreters/IInterpreter.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
class Acce<|fim_middle|>ssControl;
class ASTShowGrantsQuery;
struc... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/Context.h>
#include <Interpreters/InterpreterFactory.h>
#include <Interpreters/Access/InterpreterShowPrivilegesQuery.h>
#include <Interpreters/executeQuery.h>
namespace DB
<|fim_suffix|>ry_ptr_, ContextMutablePtr context_)
: query_ptr(query_ptr_), context(context_)
{
}
Block... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>PrivilegesQuery : public IInterpreter
{
public:
InterpreterShowPrivilegesQuery(const ASTPtr & query_ptr_, ContextMutablePtr context_);
BlockIO execute() override;
bool ignoreQuota() const override { return true; }
bool ignoreLimits() const override { return true; }
private:
ASTPtr q... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/Access/getValidUntilFromAST.h>
#include <Interpreters/evaluateConstantExpression.h>
#include <IO/parseDateTimeBestEffort.h>
#include <IO/ReadHelpers.h>
#include <IO/ReadBufferFromString.h>
#include <Storages/checkAndGetLiteralArgument.h>
namespace DB
{
time_t getValidUntilFromA... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>.h>
#include <ctime>
namespace DB
{
time_t getValidUntilFromAST(ASTPtr valid_until, ContextPtr context);
}
<|fim_prefix|>#pragma once
#include <Parsers/IAST_fwd.h>
#include <Interpreters/Context_fw<|fim_middle|>d<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/ActionLocksManager.h>
#include <Interpreters/Context.h>
#include <Interpreters/DatabaseCatalog.h>
#include <Databases/IDatabase.h>
#include <Storages/IStorage.h>
namespace DB
{
namespace ActionLocks
{
extern const StorageActionBlockType PartsMerge = 1;
extern const Storag... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#prag<|fim_suffix|>;
};
}
<|fim_middle|>ma once
#include <Interpreters/Context_fwd.h>
#include <Interpreters/StorageID.h>
#include <Storages/IStorage_fwd.h>
#include <Common/ActionLock.h>
#include <base/types.h>
#include <mutex>
#include <unordered_map>
namespace DB
{
/// Holds ActionLocks for table... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> columns order.
std::optional<ActionsForFilterPushDown> splitActionsForFilterPushDown(
const std::string & filter_name,
bool removes_filter,
const Names & available_inputs,
const ColumnsWithTypeAndName & all_inputs,
bool allow_non_deterministic_functions);
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> a display name and a column id.
while (hasColumn(result))
{
result = prefix + "_" + toString(next_unique_suffix);
++next_unique_suffix;
}
return result;
}
}
<|fim_prefix|>#include <IO/WriteHelpers.h>
#include <Interpreters/ActionsMatcher.h>
namespace DB
{
String Action... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Pair> getNameAndTypeFromAST(const ASTPtr & ast, Data & data);
};
}
<|fim_prefix|>#pragma once
#include <Core/ColumnNumbers.h>
#include <Core/ColumnWithTypeAndName.h>
#include <Core/NamesAndTypes.h>
#include <Interpreters/ActionsDAG.h>
#include <Interpreters/Context_fwd.h>
#include <Parsers/IAST_fwd.h>
#... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>!= "tuple")
throw Exception(ErrorCodes::TYPE_MISMATCH, "First argument of lambda must be a tuple");
has_lambda_arguments = true;
argument_types.emplace_back(std::make_shared<DataTypeFunction>(DataTypes(lambda_args_tuple->arguments->children.size())));
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>{
using ActionsVisitor = ConstInDepthNodeVisitor<ActionsMatcher, true>;
}
<|fim_prefix|>#pragma once
#include <Interpreters/ActionsMatcher.h>
#include <Interpreters/InDepth<|fim_middle|>NodeVisitor.h>
namespace DB
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/typeid_cast.h>
#include <Parsers/ASTWithElement.h>
#include <Parsers/ASTLiteral.h>
#include <Parsers/ASTQueryWithTableAndOutput.h>
#include <Parsers/ASTRenameQuery.h>
#include <Parsers/ASTIdentifier.h>
#include <Parsers/ASTRefreshStrategy.h>
#include <Parsers/ASTSelectQuery.... | fim | ClickHouse/ClickHouse | c |
#include <Interpreters/AddIndexConstraintsOptimizer.h>
#include <Interpreters/TreeCNFConverter.h>
#include <Parsers/IAST_fwd.h>
#include <Parsers/ASTIdentifier.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTConstraintDeclaration.h>
#include <Storages/StorageInMemoryMetadata.h>
#include <Parsers/ASTSelectQuer... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tries to add function 'indexHint' to
/// WHERE clause, which reduces amount of read data.
class AddIndexConstraintsOptimizer final
{
public:
explicit AddIndexConstraintsOptimizer(const StorageMetadataPtr & metadata_snapshot);
void perform(CNFQuery & cnf_query);
private:
const StorageMetadata... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>adStringBinary(function_name, in);
UInt64 num_params = 0;
readVarUInt(num_params, in);
aggregate.parameters.resize(num_params);
for (auto & param : aggregate.parameters)
param = readFieldBinary(in);
auto action = NullsAction::EMPTY; /// As I understand... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <AggregateFunctions/IAggregateFunction_fwd.h>
#include <Core/ColumnNumbers.h>
#include <Core/Field.h>
#include <Core/Names.h>
#include <Core/Types.h>
namespace DB
{
class WriteBuffer;
struct ExplainFormatSettings;
namespace J<|fim_suffix|>_t additonal_indent) const; /// Get descr... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <Interpreters/InDepthNodeVisitor.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTSetQuery.h>
#include <Parsers/ASTTablesInSelectQuery.h>
#include <Parsers/IAST.h>
#include <Parsers/ASTSubquery.h>
namespace DB
{
/// Recursive traversal and check for optimizeAggregateFunctionsOfGroupByKe... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <AggregateFunctions/IAggregateFunction_fwd.h>
#include <Common/HashTable/FixedHashMap.h>
#include <Common/HashTable/StringHashMap.h>
#include <Common/HashTable/TwoLevelHashMap.h>
#include <Common/HashTable/TwoLevelStringHashMap.h>
namespace DB
{
/** Different data structures tha... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/AggregatedDataVariants.h>
#include <Interpreters/Aggregator.h>
#include <Core/Block.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/IDataType.h>
#include <Poco/Logger.h>
#include <Common/HashTable/HashTableTraits.h>
#inclu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Block_fwd.h>
#include <Core/Names.h>
#include <Interpreters/AggregatedData.h>
#include <Interpreters/AggregationMethod.h>
#include <memory>
#include <boost/noncopyable.hpp>
namespace DB
{
namespace ColumnsHashing
{
struct HashMethodContextSettings;
}
class Arena;
class Agg... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Interpreters/AggregatedZooKeeperLog.h>
#include <DataTypes/DataTypeLowCardinality.h>
#include <DataTypes/DataTypeMap.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeDateTime.h>
#include <Parsers/Expr... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> PeriodicLog<AggregatedZooKeeperLogElement>
{
using PeriodicLog<AggregatedZooKeeperLogElement>::PeriodicLog;
protected:
void stepFunction(TimePoint current_time) override;
public:
void observe(
Int64 session_id,
Int32 operation,
const std::filesystem::path & path,
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/Exception.h>
#include <Common/assert_cast.h>
#include <Core/Defines.h>
#include <Columns/IColumn.h>
#include <Columns/ColumnsNumber.h>
#include <Interpreters/KeysNullMap.h>
#if defined(__SSSE3__) && !defined(MEMORY_SANITIZER)
#include <tmmintrin.h>
#endif
namespace DB
{
na... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> AggregationMethodSerialized<AggregatedDataWithStringKeyTwoLevel, true, true>;
template struct AggregationMethodSerialized<AggregatedDataWithStringKeyHash64, true, true>;
}
<|fim_prefix|>#include <Interpreters/AggregatedData.h>
#include <Interpreters/AggregationMethod.h>
#include <IO/ReadBufferFromString... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <vector>
#include <Common/ColumnsHashing.h>
#include <Columns/ColumnString.h>
namespace DB
{
class IColumn;
/// For the case where there is one numeric key.
/// FieldType is UInt8/16/32/64 for any type with corresponding bit width.
template <typename FieldType, typename TData,
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <AggregateFunctions/IAggregateFunction.h>
#include <Columns/ColumnAggregateFunction.h>
#include <Interpreters/AggregationUtils.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
OutputBlockColumns prepareOutputBlockColumns(
const Aggregator::Params & params,
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ggregates_pools,
bool final,
size_t rows);
Chunk finalizeChunk(
const Aggregator::Params & params,
OutputBlockColumns && out_cols,
bool final);
}
<|fim_prefix|>#pragma once
#include <Interpreters/Aggregator.h>
namespace DB
{
struct OutputBlockColumns
{
MutableColumns key_column... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <memory>
#include <mutex>
#include <type_traits>
#include <AggregateFunctions/IAggregateFunction_fwd.h>
#include <Core/Block.h>
#include <Processors/Chunk.h>
#include <Core/Block_fwd.h>
#include <Core/ColumnNumbers.h>
#include <Common/Logger.h>
#include <Common/VectorWithMemoryTra... | fim | ClickHouse/ClickHouse | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.