text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>#include <Formats/EscapingRuleUtils.h>
#include <Formats/SchemaInferenceUtils.h>
#include <DataTypes/Serializations/SerializationNullable.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypeFactory.h>
#include <DataTypes/DataTypeNothing.h>
#include ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ettings, FormatSettings::EscapingRule escaping_rule, JSONInferenceInfo * json_info = nullptr);
DataTypes tryInferDataTypesByEscapingRule(const std::vector<String> & fields, const FormatSettings & format_settings, FormatSettings::EscapingRule escaping_rule, JSONInferenceInfo * json_info = nullptr);
/// Ch... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Formats/FormatFactory.h>
#include <unistd.h>
#include <Formats/FormatSettings.h>
#include <Formats/FormatParserSharedResources.h>
#include <Formats/FormatFilterInfo.h>
#include <Interpreters/Context.h>
#include <Interpreters/ProcessList.h>
#include <IO/ParallelReadBuffer.h>
#include <IO/SharedT... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Formats/FormatSettings.h>
#include <IO/BufferWithOwnMemory.h>
#include <IO/CompressionMethod.h>
#include <Interpreters/Context_fwd.h>
#include <Disks/DiskObjectStorage/ObjectStorages/IObjectStorage.h>
#include <base/types.h>
#include <Common/Allocator.h>
#include <Common/NamePrompt... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>s_dag != nullptr;
}
Block FormatFilterInfo::buildKeyConditionInputs(
Block base,
const PrewhereInfoPtr & prewhere_info,
const FilterDAGInfoPtr & row_level_filter)
{
auto add_required = [&](const ActionsDAG & dag)
{
for (const auto & col : dag.getRequiredColumns())
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <exception>
#include <mutex>
#include <Interpreters/Context_fwd.h>
#include <Core/Block.h>
namespace DB
{
class ActionsDAG;
struct Settings;
class KeyCondition;
struct PrewhereInfo;
using PrewhereInfoPtr = std::shared_ptr<PrewhereInfo>;
struct FilterDAGInfo;
using FilterDAGInfoPtr... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Formats/FormatParserSharedResources.h>
#include <Core/Settings.h>
#include <Storages/MergeTree/KeyCondition.h>
#include <Interpreters/ExpressionActions.h>
namespace DB
{
namespace Setting
{
extern<|fim_suffix|>;
return (max_parsing_threads + n - 1) / n;
}
size_t FormatParserSharedReso... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
<|fim_suffix|>lds above.
std::once_flag init_flag;
std::exception_ptr init_exception;
};
}
<|fim_middle|>#include <Common/threadPoolCallbackRunner.h>
#include <Interpreters/Context_fwd.h>
namespace DB
{
struct Settings;
struct FormatParserSharedResources;
using FormatParserSharedR... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tSchemaInfo>(
/*format_schema_source=*/FormatSettings::FORMAT_SCHEMA_SOURCE_FILE,
/*format_schema=*/schema_path,
/*format_schema_message_name=*/"Message",
/*format=*/format,
/*require_message=*/true,
/*is_server*/ settings.schema.is_server,
/*format_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Formats/StructureToCapnProtoSchema.h>
#include <Formats/StructureToProtobufSchema.h>
#include <base/types.h>
#include <Common/Macros.h>
#include <filesystem>
namespace DB
{
class Context;
class Block;
struct FormatSettings;
namespace fs = std::filesystem;
/// Extracts informati... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/Defines.h>
#include <Core/Names.h>
#include <base/types.h>
#include <base/unit.h>
namespace DB
{
/**
* Various tweaks for input/output formats. Text serialization/deserialization
* of data types also depend on some of these settings. It is different from
* FormatFactor... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Formats/IndexForNativeFormat.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
namespace DB
{
namespace ErrorCodes
{
extern const int INCORRECT_INDEX;
}
void IndexOfBlockForNativeFormat::read(ReadBuffer & istr)
{
readVarUInt(num_columns, istr);
readVarUInt(num_rows, ist... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>et & required_columns) const;
};
}
<|fim_prefix|>#pragma once
#include <Core/Names.h>
#include <Formats/MarkInCompressedFile.h>
namespace DB
{
class ReadBuffer;
class WriteBuffer;
/** The Native format can contain a separately located index,
* which allows you to understand where what column is lo... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <DataTypes/IDataType.h>
#include <Columns/IColumn_fwd.h>
namespace DB
{
struct FormatSettings;
struct JSONExtractInsertSettings
{
/// If true, when complex type like Array/Map has both valid and invalid elements,
/// the default value will be inserted on invalid elements.
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <Formats/JSONUtils.h>
#include <Formats/ReadSchemaUtils.h>
#include <Formats/EscapingRuleUtils.h>
#include <IO/PeekableReadBuffer.h>
#include <IO/ReadBufferFromString.h>
#include <IO/WriteBufferValidUTF8.h>
#include <DataTypes/Serialization... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>& settings);
void validateMetadataByHeader(const NamesAndTypesList & names_and_types_from_metadata, const Block & header);
bool skipUntilFieldInObject(ReadBuffer & in, const String & desired_field_name, const FormatSettings::JSON & settings);
void skipTheRestOfObject(ReadBuffer & in, const Fo... | fim | ClickHouse/ClickHouse | c |
#include <Formats/MarkInCompressedFile.h>
#include <Common/BitHelpers.h>
#include <Common/Exception.h>
#include <IO/WriteHelpers.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
String MarkInCompressedFile::toString() const
{
return "(" + DB::toString(offset_in_compressed_file) + "... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <tuple>
#include <unorde<|fim_suffix|>e required, but the bigger the relative overhead of
* block headers.
*
* Packed marks and block headers all live in one contiguous array.
*/
struct BlockInfo
{
// Min offset_in_compressed_file and offset_in_d... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
namespace DB
{
e<|fim_suffix|>t8_t
{
UUIDType = 0x02,
};
}
<|fim_middle|>num class MsgPackExtensionTypes : uin<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>,
ValueSizeMap * avg_value_size_hints_)
{
ISerialization::DeserializeBinaryBulkSettings settings;
settings.getter = [&](ISerialization::SubstreamPath) -> ReadBuffer * { return &istr; };
settings.position_independent_encoding = false;
settings.native_format = true;
settings.format_s... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ating columns of variable size.
ValueSizeMap avg_value_size_hints;
};
}
<|fim_prefix|>#pragma once
#include <Formats/FormatSettings.h>
#include <Formats/IndexForNativeFormat.h>
#include <Formats/MarkInCompressedFile.h>
#include <Core/Block.h>
#include <Core/BlockMissingValues.h>
#include <map>
nam... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>lock.columns.resize(columns);
}
for (size_t i = 0; i < columns; ++i)
{
/// For the index.
MarkInCompressedFile mark{0, 0};
if (index)
{
ostr_concrete->next(); /// Finish compressed block.
mark.offset_in_compressed_file = initial_size_o... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Block_fwd.h>
#include <DataTypes/IDataType.h>
#include <Formats/FormatSettings.h>
namespace DB
{
struct ColumnWithTypeAndName;
class WriteBuffer;
class CompressedWriteBuffer;
struct IndexForNativeFormat;
/** Serializes t<|fim_suffix|> in their native binary format (with nam... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <cstddef>
#include <Storages/NamedCollectionsHelpers.h>
#include <IO/WriteBufferFromString.h>
#include <IO/WriteHelpers.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
extern const int NOT_IMPLEMENTED;
}
enum class NumpyDataTypeIndex : uint8_t
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
|| code == ErrorCodes::CANNOT_PARSE_NUMBER
|| code == ErrorCodes::CANNOT_PARSE_UUID
|| code == ErrorCodes::CANNOT_PARSE_BOOL
|| code == ErrorCodes::CANNOT_READ_ARRAY_FROM_TEXT
|| code == ErrorCodes::CANNOT_READ_MAP_FROM_TEXT
|| code == ErrorCodes::CANNOT_RE... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
namespace DB
{
/// Returns true if the error code corresponds to a recoverable error in the input data
/// (a parsing error) rather than a fatal one (e.g. MEMORY_LIMIT_EXCEEDED).
///
/// It is used<|fim_suffix|>e
/// deserialization code that restores a column after a failed read must rethr... | fim | ClickHouse/ClickHouse | c |
#include <Formats/ParsedTemplateFormatString.h>
#include <Formats/verbosePrintString.h>
#include <Formats/EscapingRuleUtils.h>
#include <IO/ReadBufferFromMemory.h>
#include <IO/Operators.h>
#include <IO/ReadBufferFromFile.h>
#include <Interpreters/Context.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>t(const String & message, size_t column) const;
};
}
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <functional>
#include <optional>
#include <vector>
#include <Formats/FormatSchemaInfo.h>
#include <Formats/FormatSettings.h>
namespace DB
{
class Block;
using Strings = std::vector<String>... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/IColumn.h>
#include <Formats/PrettyFormatHelpers.h>
#include <IO/WriteBuffer.h>
#include <IO/WriteHelpers.h>
#include <Processors/Chunk.h>
#include <Common/formatReadable.h>
#include <Common/UTF8Helpers.h>
static constexpr const char * GRAY_COLOR = "\033[90m";
static constexpr const ch... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>g source);
/// If the visible width of the name is longer than `cut_to` + `hysteresis`,
/// and it isn't a proper identifier, truncate it to `cut_to`
/// by cutting it in the middle and replacing with a single filler character (ascii or unicode).
std::pair<String, size_t> truncateName(String name, size_t... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Formats/ProtobufReader.h>
#if USE_PROTOBUF
# include <IO/ReadHelpers.h>
namespace DB
{
namespace ErrorCodes
{
extern const int UNKNOWN_PROTOBUF_FORMAT;
}
namespace
{
enum WireType
{
VARINT = 0,
BITS64 = 1,
LENGTH_DELIMITED = 2,
GROUP_START = 3,
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>nt_message_end = 0;
std::vector<Int64> parent_message_ends;
int field_number = 0;
int next_field_number = 0;
Int64 field_end = 0;
};
}
#endif
<|fim_prefix|>#pragma once
#include "config.h"
#if USE_PROTOBUF
# include <Common/PODArray.h>
# include <IO/ReadBuffer.h>
# include <vecto... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> should not be stored in the import cache. Generated schemas are typically temporary and
/// may throw exceptions during type inference (e.g., protobufSchemaToCHSchema). Caching them could pollute the
/// global cache with invalid importers, leading to failures in subsequent schema inference. Inst... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tring schema_path;
WithEnvelope with_envelope;
bool operator==(const ImporterKey & other) const = default;
};
struct ImporterKeyHash
{
size_t operator()(const ImporterKey & key) const
{
SipHash hash;
hash.update(key.schema_directory);
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include "config.h"<|fim_suffix|>onst Strings & column_names,
const DataTypes & data_types,
const ProtobufSchemas::DescriptorHolder & descriptor,
bool with_length_delimiter,
bool with_envelope,
bool defaults_for_nullable_google_wrappers,
Protob... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Formats/ProtobufWriter.h>
#if USE_PROTOBUF
# include <IO/WriteHelpers.h>
namespace DB
{
namespace
{
constexpr size_t MAX_VARINT_SIZE = 10;
constexpr size_t REPEATED_PACK_PADDING = 2 * MAX_VARINT_SIZE;
constexpr size_t NESTED_MESSAGE_PADDING = 2 * MAX_VARINT_SIZE;
// Note: T... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include "config.h"
#if USE_PROTOBUF
# include <Core/Types.h>
# include <Common/PODArray.h>
namespace DB
{
class WriteBuffer;
/// Utility class for writing in the Protobuf format.
/// Knows nothing about protobuf schemas, just provides useful functions to serialize data.
class ProtobufWriter
{
pub... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>n makeSchemaCacheKey(source, format, additional_format_info, schema_inference_mode); });
return cache_keys;
}
}
<|fim_prefix|>#include <Core/Settings.h>
#include <Formats/FormatFactory.h>
#include <Formats/ReadSchemaUtils.h>
#include <IO/EmptyReadBuffer.h>
#include <IO/PeekableReadBuffer.h>
#include ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <IO/ReadBuffer.h>
#include <Formats/FormatSettings.h>
#include <Storages/Cache/SchemaCache.h>
#include <Storages/ColumnsDescription.h>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
}
struct IReadBufferIterator
{
virtual ~IReadBufferIterator() = d... | fim | ClickHouse/ClickHouse | c |
#include <Common/Exception.h>
#include <Formats/RowInputMissingColumnsFiller.h>
#include <Columns/ColumnArray.h>
#include <DataTypes/NestedUtils.h>
#include <boost/range/adaptor/map.hpp>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_COLUMN;
}
RowInputMissingColumnsFiller::RowInputMissingColumn... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>std::vector<ColumnInfo> column_infos;
NamesAndTypesList names_and_types;
};
}
<|fim_prefix|>#pragma once
#include <Columns/IColumn_fwd.h>
#include <Core/Names.h>
#include <Core/NamesAndTypes.h>
#include <DataTypes/IDataType.h>
namespace DB
{
/// Adds default values to columns if they don't have a ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Formats/SchemaInferenceUtils.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypeDateTime64.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeDate.h>
#include <DataTypes/DataTypeA... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <DataTypes/IDataType.h>
#include <Common/DateLUTImpl.h>
#include <IO/ReadBuffer.h>
#include <vector>
namespace DB
{
class Block;
struct FormatSettings;
class NamesAndTypesList;
using NamesAndTypesLists = std::vector<NamesAndTypesList>;
/// Struct with some additional information about inferre... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>x, indent + 2);
writeFieldDefinition(buf, value_type_name, "value", field_index, indent + 2);
endNested(buf, indent + 1);
field_index = 0;
writeFieldDefinition(buf, "List(Entry)", "entries", field_index, indent + 1);
endNested(buf, indent);
return struct_name;
}
template <typename... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types<|fim_suffix|>ructureToCapnProtoSchema
{
static constexpr auto name = "structureToCapnProtoSchema";
static void
writeSchema(WriteBuffer & buf, const String & message_name, const NamesAndTypesList & names_and_types_, bool with_envelope = false);
};
}
<|fim_mi... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Formats/StructureToFormatSchemaUtils.h>
#include <IO/WriteHelpers.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
namespace StructureToFormatSchemaUtils
{
void writeIndent(WriteBuffer & buf, size_t indent)
{
writeChar(' ', indent * 4, buf);
}
void startNes... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/NamesAndTypes.h>
#include <DataTypes/NestedUtils.h>
#include <DataTypes/Data<|fim_suffix|>ring getSchemaMessageName(const String & column_name);
NamesAndTypesList collectNested(const NamesAndTypesList & names_and_types, bool allow_split_by_underscore, const String & forma... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> case TypeIndex::Array:
return prepareArrayAndGetProtobufTypeName(buf, data_type, column_name, indent);
case TypeIndex::Tuple:
return prepareTupleAndGetProtobufTypeName(buf, data_type, column_name, indent);
case TypeIndex::Map:
return prepareMapAnd... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <IO/WriteBuffer.h>
#include <Core/NamesAndTypes.h>
namespace DB
{
struct StructureToProtobufSchema
{
static constexpr auto name = "structureToProtobufSchema";
static void
writeSchema(WriteBuffer & buf, const String & message_name, const NamesAndTypesList & names_and_types_, bool wi... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/Block.h>
#include <Formats/formatBlock.h>
#include <|fim_suffix|>nk.h>
#include <QueryPipeline/QueryPipeline.h>
#include <Processors/Executors/CompletedPipelineExecutor.h>
namespace DB
{
void formatBlock(OutputFormatPtr out, const Block & block)
{
auto source = std::make_shared<Source... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <memory>
namespace DB
{
class Block;
class IOutputFormat;
using OutputFormatPtr = std::shared_ptr<IOutputFormat>;
void formatBlock(OutputFormatPtr out, const Block & block);
}
<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <base/types.h>
#include <Core/Settings.h>
#include <IO/ReadBufferFromMemory.h>
#include <IO/ReadHelpers.h>
#include <Formats/registerFormats.h>
#include <QueryPipeline/Pipe.h>
#include <QueryPipeline/QueryPipeline.h>
#include <Processors/Formats/IInputFormat.h>
#include <Processors/Executors... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <Formats/insertNullAsDefaultIfNeeded.h>
#include <Columns/ColumnNullable.h>
#include <Columns/ColumnArray.h>
#include <Columns/ColumnTuple.h>
#include <Columns/ColumnMap.h>
#include <Columns/ColumnLowCardinality.h>
#include <DataTypes/DataTypeNullable.h>
#include <DataTypes/DataTypeArray.h>
#incl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/BlockMissingValues.h>
namespace DB
{
st<|fim_suffix|>l insertNullAsDefaultIfNeeded(ColumnWithTypeAndName & input_column, const ColumnWithTypeAndName & header_column, size_t column_i, BlockMissingValues * block_missing_values);
}
<|fim_middle|>ruct ColumnWithTypeAndName;
boo... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include "config.h"
#include <Formats/FormatFactory.h>
namespace DB
{
/// File Segmentation Engines for parallel reading
void registerFileSegmentationEngineTabSeparated(FormatFactory & factory);
void registerFileSegmentationEngineCSV(FormatFactory & factory);
void registerFileSegmentationEngineJSONEa... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
namespace DB
{
void re<|fim_suffix|>();
}
<|fim_middle|>gisterFormats<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Formats/FormatFactory.h>
#include <Formats/registerWithNamesAndTypes.h>
namespace DB
{
void registerWithNamesAndTypes(const std::string & base_format_name, RegisterWithNamesAndTypesFunc register_func)
{
register_func(base_format_name, false, false);
register_func(base_format_name + "Wi... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <string>
#include <functional>
namespace DB
{
class FormatFactory;
using RegisterWithNamesAndTypesFunc = std::function<void(const std::string & format_name, bool with_names, bool with_types)>;
void registerWithNamesAndTypes(const std::string & base_format_name, RegisterWithNamesAndTypesFunc reg... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>marks.get(i), plain[i]);
EXPECT_LE((marks.approximateMemoryUsage() - sizeof(MarksInCompressedFile)) * 8, plain.size() * max_bits_per_mark);
};
{
SCOPED_TRACE("Typical");
test(gen(10000, 1'000'000, 0), 30);
}
{
SCOPED_TRACE("Completely random 64-bit value... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>OTE>";
break;
case '\'':
out << "<SINGLE QUOTE>";
break;
default:
{
if (static_cast<unsigned char>(*pos) < 32) /// ASCII control characters
out << "<0x" << hexDigitUppercase(*pos / 16)... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
namespace DB
{
class WriteBuffer;
/** Print string in double quotes and with control characters in "<NAME>" form - for output diagnostic info to user<|fim_suffix|>oid verbosePrintString(const char * begin, const char * end, WriteBuffer & out);
}
<|fim_middle|>.
*/
v<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> if (throw_on_quota_exceeded)
throw Exception(ErrorCodes::LIMIT_EXCEEDED,
"AI input token limit reached or exceeded: {} tokens consumed, maximum: {}. "
"This is controlled by the 'ai_function_max_input_tokens_per_query' setting",
input_toke... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tokens = 0;
UInt64 output_tokens = 0;
UInt64 api_calls = 0;
};
}
<|fim_prefix|>#pragma once
#include <Core/Types.h>
#include <Common/Exception.h>
namespace DB
{
class AIQuotaTracker
{
public:
AIQuotaTracker(
UInt64 max_input_tokens_, UInt64 max_output_tokens_,
UInt64 max_ap... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/AI/AnthropicProvider.h>
#include <IO/HTTPCommon.h>
#include <Common/Exception.h>
#include <Poco/Net/HTTPRequest.h>
#include <Poco/Net/HTTPResponse.h>
#include <Poco/URI.h>
#include <Poco/JSON/Parser.h>
#include <Poco/JSON/Object.h>
namespace DB
{
namespace ErrorCodes
{
extern co... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
<|fim_suffix|>Timeouts & timeouts) override;
private:
const String endpoint;
const String api_key;
const String api_version;
const Poco::URI uri;
};
}
<|fim_middle|>#include <Functions/AI/IAIProvider.h>
namespace DB
{
/** Anthropic Messages API
* https://platform.claude... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/AI/IAIProvider.h>
#include <Functions/AI/OpenAIProvider.h>
#include <Functions/AI/AnthropicProvider.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
extern const int NOT_IMPLEMENTED;
}
AIEmbeddingResponse IAIProvider::emb... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/VectorWithMemoryTracking.h>
#include <Core/Types.h>
#include <IO/ConnectionTimeouts.h>
#include <Poco/JSON/Object.h>
#include <memory>
namespace DB
{
/** Parameters for a single AI chat completion request.
*
* Each row processed by an AI function produces one AIRequest... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
std::ostringstream ss; /// STYLE_CHECK_ALLOW_STD_STRING_STREAM
ss << in_stream.rdbuf();
response_body = std::move(ss).str();
}
auto status = http_response.getStatus();
if (status != Poco::Net::HTTPResponse::HTTP_OK)
{
throw Exception(
ErrorCode... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> const Poco::URI uri;
};
}
<|fim_prefix|>#pragma once
#include <Functions/AI/IAIProvider.h>
namespace DB
{
/** OpenAI Chat Completions and Embeddings APIs
* https://developers.openai.com/api/reference/resources/chat
* https://developers.openai.com/api/reference/resources/embeddings
*
* Also ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>urnedValue returned_value_crc64 = {"Returns the CRC64 checksum of the string.", {"UInt64"}};
FunctionDocumentation::Examples examples_crc64 = {
{
"Usage example",
"SELECT CRC64('ClickHouse');",
R"(
┌──CRC64('ClickHouse')─┐
│ 12126588151325169346 │
└──────────────────────┘
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>CastOrNull_arguments, {}, accurateCastOrNull_returned_value, accurateCastOrNull_examples, accurateCastOrNull_introduced_in, accurateCastOrNull_category};
factory.registerFunction("CAST", [](ContextPtr context){ return CastOverloadResolverImpl::create(context, CastType::nonAccurate, false, {}); }, CAS... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ic, ContextPtr context);
}
<|fim_prefix|>#pragma once
#include <memory>
#include <optional>
#include <Interpreters/Context_fwd.h>
#include <Core/ColumnWithTypeAndName.h>
namespace DB
{
class IFunctionOverloadResolver;
using FunctionOverloadResolverPtr = std::shared_ptr<IFunctionOverloadResolver>;
cl... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>bleForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; }
DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
{
if (arguments.empty() || arguments.size() > 2)
throw Exception(
Error... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>};
struct NameLessOrEquals { static constexpr auto name = "lessOrEquals"; };
struct NameGreaterOrEquals { static constexpr auto name = "greaterOrEquals"; };
}
<|fim_prefix|>#pragma once
/// Lightweight header with just the comparison functio<|fim_middle|>n name structs.
/// Use this instead of Functi... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Core/Settings.h>
#include <Interpreters/Context.h>
#include <Functions/FunctionsComparison.h>
namespace DB
{
namespace Setting
{
extern const SettingsBool validate_enum_literals_in_operators;
extern const SettingsBool use_variant_default_implementation_for_comparisons;
extern const... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Functions/PositionImpl.h>
#include <string>
#include <vector>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_COLUMN;
}
/// Implementation of the countSubstrings() using helpers for position()
///
/// NOTE: Intersecting substrings in haystack accounted only once, i.e.:
//... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <Columns/ColumnString.h>
#include <Columns/ColumnVector.h>
#include <Columns/ColumnsNumber.h>
#include <Common/DateLUTImpl.h>
#include <Common/Exception.h>
#include <Core/DecimalFunctions.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/DateTimeTransforms.h>
#include <Functions/Functi... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>);
}
void throwTimeIsNotSupported(const char * name)
{
throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal argument of type Time for function {}", name);
}
}
<|fim_prefix|>#include <Functions/DateTimeTransforms.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_O... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> & time_zone)
{
return static_cast<UInt16>(time_zone.toDayNum(static_cast<time_t>(t)));
}
static auto execute(Int32 d, const DateLUTImpl &)
{
if constexpr (precision_ == ResultPrecision::Extended)
return static_cast<Int32>(static_cast<ExtendedDayNum>(d));
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ow Exception(ErrorCodes::ILLEGAL_DIVISION, "Division by the most negative number");
return static_cast<ResultType>(
res + (b >= 0 ? static_cast<OriginResultType>(b) : static_cast<OriginResultType>(-b)));
}
}
}
return s... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <base/memcmpSmall.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <DataTypes/IDataType.h>
#include <Core/Field.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/StringUtils.h>
#include <Common/UTF8Helpers.h>
#include <algorithm>
#include <climits>
#include <cstring>
#include <memory>
#include <utility>
#ifdef __SSE4_2__
# include <nmmintrin.h>
#endif
namespace DB
{
// used by FunctionsStringSimilarity and FunctionsStringHash
/... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
<|fim_suffix|>/ A left-closed and right-open interval representing the preimage of a function.
struct FieldInterval
{
Field first;
Field second;
};
}
<|fim_middle|>#include <Core/Field.h>
namespace DB
{
//<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <memory>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Interpreters/Context.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Functions/FunctionBaseXXConversion.h>
#include <Common/Base32.h>
#include <functional>
namespace DB
{
struct Base32EncodeTraits
{
/// Base32 conversion is linear, so there is no size limit.
static constexpr size_t max_input_size = 0;
template <typename Col>
stat... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>64(reinterpret_cast<const UInt8 *>(src.data()), src.size(), dst);
return decodeBase58(reinterpret_cast<const UInt8 *>(src.data()), src.size(), dst, check_cancellation);
}
};
}
<|fim_prefix|>#pragma once
#include <Functions/FunctionBaseXXConversion.h>
#include <Common/Base58.h>
#include <fun... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include "config.h"
#if USE_BASE64
# include <base/MemorySanitizer.h>
# include <Columns/ColumnFixedString.h>
# include <Columns/ColumnString.h>
# include <DataTypes/DataTypeString.h>
# include <Functions/FunctionBaseXXConversion.h>
# include <Interpreters/Context_fwd.h>
# include <li... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Functions/FunctionBaseAI.h>
#include <Access/Common/AccessType.h>
#include <Access/ContextAccess.h>
#include <Common/ProfileEvents.h>
#include <Common/Exception.h>
#include <thread>
#include <Common/logger_useful.h>
#include <Common/NamedCollections/NamedCollectionsFactory.h>
#include <Common/Re... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Functions/IFunction.h>
#include <Functions/FunctionFactory.h>
#include <Functions/AI/IAIProvider.h>
#include <Functions/AI/AIQuotaTracker.h>
#include <DataTypes/DataTypeNullable.h>
#include <Interpreters/Context.h>
namespace DB
{
static constexpr UInt64 DEFAULT_AI_MAX_TOKENS = 10... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Columns/ColumnFixedString.h>
#include <Columns/ColumnString.h>
#include <Core/Settings.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionFactory.h>
#include <Functions/FunctionHelpers.h>
#include <Interpreters/Context.h>
#include <Interpreters/ProcessList.h>
#inc... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>] = static_cast<ValueType>(mask[i] | (static_cast<ValueType>(1) << pos[i]));
else
throw Exception(ErrorCodes::PARAMETER_OUT_OF_BOUND,
"The bit position argument {} is out of bounds for number", static_cast<UInt64>(pos[i]));
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include <Functions/FunctionHelpers.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Interpreters/Context_fwd.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_OF_ARGUMEN... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>d; }
bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; }
ColumnPtr executeImpl(const ColumnsWithTypeAndName &, const DataTypePtr & result_type, size_t input_rows_count) const override
{
return result_type->cr... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/Settings.h>
#include <Functions/IFunctionCustomWeek.h>
#include <Interpreters/Context.h>
namespace DB
{
namespace Setting
{
extern const SettingsBool enable_extended_results_for_datetime_functions;
}
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
}
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Functions/IFunctionCustomWeek.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
}
/// See CustomWeekTransforms.h
template <typename ToDataType, typename Transform>
class FunctionCustomWeekToSomething final : public IFunctionCustomWeek<Transf... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> // timezone
std::declval<DateLUTImpl>(), // utc
0 // scale
)
);
};
template <typename FromDataType>
using TransformExecuteReturnType = typename TransformExecuteReturnTypeImpl<FromDataType>::type;
// Deduce... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/Settings.h>
#include <Functions/IFunctionDateOrDateTime.h>
#include <Interpreters/Context.h>
namespace DB
{
namespace Setting
{
extern const SettingsBool enable_extended_results_for_datetime_functions;
}
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_OF_ARGUMENT... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>TransformDateTime64<Transform> transformer(scale);
if (enable_extended_results_for_datetime_functions)
return DateTimeTransformImpl<DataTypeDateTime64, DataTypeDateTime64, decltype(transformer), /*is_extended_result*/ true>::
execute(arguments, result_type, ... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <DataTypes/DataTypeInterval.h>
#include <DataTypes/DataTypesNumber.h>
#include <Functions/IFunctionDateOrDateTime.h>
#include <Interpreters/castColumn.h>
namespace DB
{
namespace ErrorCodes
{
extern const int ILLEGAL_TYPE_OF_ARGUMENT;
extern const int NOT_IMPLEMENTED;
}
/// See DateTime... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> {
const UInt128 value_hash = sipHash128AtRow(*attr_col, row_id);
/// Not in user given `values_column`
const auto * it = value_hash_to_bucket_id.find(value_hash);
if (it == value_hash_to_bucket_id.end())
continue;
... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.