text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|> break;
case TINYINT:
row.setField(i, (byte)1);
break;
case SMALLINT:
row.setField(i, (short)1);
break;
case INTEGER:
row.setField(i, 1);
... | fim | ClickHouse/ClickHouse | java |
<|fim_prefix|>/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "L... | fim | ClickHouse/ClickHouse | java |
<|fim_suffix|>8), toUInt8(8), toInt16(-16), toUInt16(16), toInt16(-32), toUInt16(32), toInt64(-64), toUInt64(64), toFloat32(32e6), toFloat32(-32e6), toFloat64(64e6), toFloat64(-64e6), 'TestString', toFixedString('ASD',3), toFixedString('ASD',5), toUUID('00000000-0000-0000-0000-000000000000'), toUUID('61f0c404-5cb3-11e7... | fim | ClickHouse/ClickHouse | csharp |
<|fim_suffix|> flash("No file part")
return redirect(request.url)
file = request.files["file"]
# If the user does not select a file, the browser submits an
# empty file without a filename.
if file.filename == "":
flash("No selected file")
return ... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>using System;
using MySql.Data.MySqlClient;
using Command<|fim_suffix|>d())
{
Console.WriteLine(reader.GetValue(0));
}
}
string dropTableSql = @"
DROP TABLE IF EXISTS test_table;";
... | fim | ClickHouse/ClickHouse | csharp |
<|fim_prefix|>using System;
using Npgsql;
using CommandLine;
class Program
{
[Option("host", HelpText = "Host of ClickHouse server")]
public string Host { get; set; } = "";
[Option("port", HelpText = "Port of ClickHouse server")]
public string Port { get; set; } = "";
[Option('u', "username", Hel... | fim | ClickHouse/ClickHouse | csharp |
<|fim_prefix|>package main
import (
"database/sql"
"flag"
"fmt"
_ "github.com/go-sql-driver/mysql"
"log"
"os"
)
func main() {
host := flag.String("host", "localhost", "mysql server address")
port := flag.Uint("port", 3306, "mysql server port")
user := flag.String("user", "", "username")
password := flag.Str... | fim | ClickHouse/ClickHouse | go |
import com.mysql.cj.MysqlType;
import java.sql.*;
public class MySQLJavaClientTest {
public static void main(String[] args) {
int i = 0;
String host = "127.0.0.1";
String port = "9004";
String user = "default";
String password = "";
String database = "default";
... | fim | ClickHouse/ClickHouse | java |
<|fim_suffix|>ection.end();
<|fim_prefix|>var mysql = require('mysql');
var connection = mysql.createConnection({
host : process.argv[2],
port : process.argv[3],
user : process.argv[4],
password : process.argv[5],
database : 'system',
});
connection.connect();
connection.query('S... | fim | ClickHouse/ClickHouse | javascript |
<|fim_prefix|><?ph<|fim_suffix|> PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
PDO::ATTR_EMULATE_PREPARES => false,
PDO::MYSQL_ATTR_DIRECT_QUERY => true,
];
$pdo = new PDO($dsn, $user, $pass, $options);
$stmt = $pdo->query("SELECT name FROM tab... | fim | ClickHouse/ClickHouse | php |
<|fim_prefix|><?php
$host = $argv[1];
$db = "system";
$user = $argv[3];
$pass = $argv[4];
$charset = "utf8mb4";
$port = $argv[2];
$dsn = "mysql:host=$host;port=$port;dbname=$db;charset=$charset";
$options = [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_F<|fim_suffix|> => "cli... | fim | ClickHouse/ClickHouse | php |
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
class JavaConnectorTest {
private static final String CREATE_TABLE_SQL = "CREATE TABLE IF NOT EXISTS default.test1 (`age` Int32, `name` String,... | fim | ClickHouse/ClickHouse | java |
<|fim_suffix|>/requirements.txt'
)
print("Running the command:", cmd)
subprocess.check_call(cmd, shell=True)
def check_docker_file_install_with_pip(filepath):
image_name = None
with open(filepath, "r", encoding="utf-8") as f:
for line in f:
if "docker build" in line:
... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from praktika import CloudInfrastructure
from praktika.infrastructure.dedicated_host import DedicatedHost
from praktika.infrastructure.ec2_instance import EC2Instance
from praktika.infrastructure.iam_instance_profile import IAMInstanceProfile
from ci.defs.defs import RunnerLabels
MAC_OS_TAHOE_IMAGE_AMI ... | fim | ClickHouse/ClickHouse | python |
#!/usr/bin/env python3
"""Reconcile the EC2 `user_data` of running macOS GitHub Actions runners.
EC2 only accepts a `ModifyInstanceAttribute` for `userData` while the instance
is stopped, and a macOS instance can only run on a Dedicated Host. Stopping a
Mac instance puts its host into a multi-hour scrub (host state `p... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>tatus
status = Result.Status.FAIL
info = []
is_failed = True
if server_died:
# Server died - status will be determined after OOM checks
is_failed = True
elif fuzzer_exit_code in (0, 137, 143):
# normal exit with timeout or OOM kill
is_failed = False
... | fim | ClickHouse/ClickHouse | python |
#!/usr/bin/env python3
import json
from datetime import datetime, timedelta
from typing import List, Optional
from ci.praktika.result import Result
from ci.praktika.utils import Shell
def fetch_org_contributors(org: str = "ClickHouse", limit: int = 1000) -> set:
"""
Fetch organization members using gh CLI.
... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> # Activate FIPS-permissive config for OpenSSL
os.environ["OPENSSL_CONF"] = "/etc/ssl/openssl.cnf"
files = []
if res and JobStages.BUILD in stages:
if build_type == BuildTypes.ARM_FUZZERS:
targets = "fuzzers"
elif build_type == BuildTypes.ARM_BINARY:
... | fim | ClickHouse/ClickHouse | python |
#!/usr/bin/env python3
import argparse
import subprocess
import sys
import os
from pathlib import Path
VENV_DIR = Path(".venv-pypy")
PRAKTIKA_DIR = Path("ci/praktika")
def run(cmd, check=True):
print(f"\n>>> Running: {' '.join(cmd)}")
subprocess.run(cmd, check=check)
def run_env(cmd, check=True, env=None)... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>{STAGE2_INSTALL_DIR}/bin/llvm-bolt"
merge_fdata = f"{STAGE2_INSTALL_DIR}/bin/merge-fdata"
clang_instrumented = f"{clang_binary}.inst"
clang_bolted = f"{clang_binary}.bolt"
clangpp_inst = None # set in step 2 if BOLT instrumentation succeeds
clean_dirs(BOLT_PROFILE... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>lose the deepest levels.
if max_nested_rows <= 5:
max_depth_high = 5
elif max_nested_rows <= 20:
max_depth_high = 4
else:
max_depth_high = 3
buzz_config = {
"seed": random.randint(1, 18446744073709551615),
"max_depth": random.randint(2, max_depth_hi... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import argparse
import math
import multiprocessing
import os
import re
from concurrent.futures import ProcessPoolExecutor
from pathlib import Path
from praktika.info import Info
from praktika.result import Result
from praktika.utils import Shell, Utils
NPROC = multiprocessing.cpu_count()
def chunk_lis... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import argparse
import shlex
from ci.jobs.integration_test_job import start_docker_in_docker
from ci.jobs.scripts.clickhouse_service import ClickHouseService
from ci.praktika.result import Result
from ci.praktika.utils import Utils
temp_path = f"{Utils.cwd()}/ci/tmp"
def parse_args():
parser = arg... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from ci.praktika.info import Info
EXTENDED_RUN_LABELS = {"pr-feature"<|fim_suffix|>_labels) & EXTENDED_RUN_LABELS)
except Exception:
return False
<|fim_middle|>, "pr-improvement", "pr-performance"}
def is_extended_run() -> bool:
try:
info = Info()
return bool(set(info.pr... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from ci.jobs.scripts.clickhouse_proc import ClickHouseProc
from ci.praktika.info import Info
from ci.praktika.result import Result
from ci.praktika.utils import Shell, Utils
temp_dir = f"{Utils.cwd()}/ci/tmp/"
def main():
res = True
results = []
stop_watch = Utils.Stopwatch()
ch = Click... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import argparse
import atexit
import dataclasses
import fcntl
import http.client
import os
import pty
import re
import select
import shlex
import subprocess
import sys
import time
import urllib.parse
from enum import Enum
from pathlib import Path
sys.path.append("./")
from typing import List
from ci.job... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> command=cmake_cmd,
workdir=PGO_BUILD_DIR,
)
)
res = results[-1].is_ok()
if res:
results.append(
Result.from_commands_run(
name="Build (PGO instrumented)",
command="command time -v ... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>ts_stat.append(Result.from_commands_run(name=job_name, command=do))
if results_stat[-1].is_ok():
is_collected = True
results.append(
Result(
name="Fetch statistics",
status=Result.Status.OK if is_collected else Result.Status.FAIL,
result... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import argparse
from pathlib import Path
from pip._vendor.packaging.version import Version
from ci.praktika.info import Info
from ci.praktika.result import Result
from ci.praktika.utils import Shell, Utils
IMAGE_UBUNTU = "clickhouse/test-old-ubuntu"
IMAGE_CENTOS = "clickhouse/test-old-centos"
DOWNLOAD_... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>"""
AI-based automated PR code review job.
Two backends are supported, selected by flag:
--codex OpenAI Codex CLI (auth: OPENAI_API_KEY from `/ci/llm/openai_api_key`)
--copilot GitHub Copilot CLI (auth: gh robot token from `/ci/robot-ch-test-poll-copilot`)
Both agents shell out to `gh... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import argparse
import atexit
import json
import logging
import os
import tempfile
import traceback
from pathlib import Path
from typing import Dict, List
from ci.jobs.scripts.clickhouse_version import CHVersion
from ci.praktika import Secret
from ci.praktika.info import Info
from ci.praktika.result impo... | fim | ClickHouse/ClickHouse | python |
import os
from ci.praktika.result import Result
from ci.praktika.utils import Shell, Utils
if __name__ == "__main__":
results = []
stop_watch = Utils.Stopwatch()
temp_dir = f"{Utils.cwd()}/ci/tmp/"
testname = "Fetch latest ClickHouse/clickhouse-docs changes"
results.append(
Result.from_c... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>k_readonly_copies(changed_files)
if __name__ == "__main__":
docs_dir = f"{Utils.cwd()}/docs"
# The mint check definitions are shared with the standalone driver
# (ci/jobs/scripts/docs/mintlify_docs_check.py). This job already runs inside
# the docs-builder image with the docs present n... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>watch_)
)
if not results[-1].is_ok():
attach_debug = True
if res and JobStages.TEST in stages:
stop_watch_ = Utils.Stopwatch()
step_name = "Tests"
print(step_name)
# Fast test runs lightweight SQL tests that are not CPU-bound,
# so ... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>total=0,
tests=list(tests) if tests else tests,
extra_args=runner_options,
random_order=True,
rerun_count=rerun_count,
global_time_limit=global_time_limit,
)
elif is_targeted_check:
TARGETED_CH... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>)
<|fim_prefix|>from praktika.result import Result
from praktika.utils import Shell, Utils
from ci.jobs.scripts.clickhouse_proc import ClickHouseProc
from ci.praktika.info import Info
temp_dir = f"{Utils.cwd()}/ci/tmp/"
def main():
res = True
results = []
stop_watch = Utils.Stopwatch()
... | fim | ClickHouse/ClickHouse | python |
import argparse
from pathlib import Path
from typing import Dict, List
from ci.jobs.scripts.docker_image import DockerImage
from ci.praktika.result import Result
from ci.praktika.utils import Shell, Utils
RPM_IMAGE = "clickhouse/install-rpm-test"
DEB_IMAGE = "clickhouse/install-deb-test"
REPO_PATH = Utils.cwd()
TEMP_... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> [
"./ci/tmp/logs.tar.gz",
"./ci/tmp/dmesg.log",
"./ci/tmp/docker-in-docker.log",
],
strict=False,
)
if args.param:
for item in args.param.split(","):
print(f"Setting env variable: {item}")
key, _, value = i... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>mentParser(
prog="Jepsen Check",
description="Check that uses Jepsen. Both Keeper and Server can be tested.",
)
parser.add_argument(
"program", help='What should be tested. Valid values "keeper", "server"'
)
args = parser.parse_args()
if args.program not in ("s... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>create_from(
name=job_name,
results=results,
stopwatch=stop_watch,
files=files_to_attach,
)
_add_grafana_links(
result,
commit_sha=env.get("COMMIT_SHA"),
stop_watch=stop_watch,
run_faults=RUN_FAULT_TESTS,
run_no_faults=RUN_NO_... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>#!/usr/bin/env python3
# Strategy of fuzzing:
# we want to minimize corpora with preserving coverage, and at the same time
# we want to include whatever additional inputs we can get from either dynamically
# generated inputs or from manual uploads. To this end we are going to firstly run
# fuzzers with -... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>g)
print_res = Result.create_from(
name="Print Uncovered Code",
status=Result.Status.OK,
info=msg,
)
print_res.set_comment(msg)
# Append high-precision hit/total counts to the log so they are visible
# in t... | fim | ClickHouse/ClickHouse | python |
import argparse
import csv
import os
import re
import subprocess
import time
import traceback
import urllib.parse
from datetime import datetime
from pathlib import Path
from ci.jobs.scripts.cidb_cluster import CIDBCluster
from ci.praktika.info import Info
from ci.praktika.result import Result
from ci.praktika.settings... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>.get_kv_data("master_commits") or []
for sha in commits:
urls = {
bt: f"https://clickhouse-builds.s3.us-east-1.amazonaws.com/REFs/master/{sha}/build_{bt}/clickhouse"
for bt in BUGFIX_BUILD_TYPES
}
if all(
Shell.check(f"curl -sfI {url} > /dev/... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>epository name (e.g., "ClickHouse/ClickHouse")
pr_num: PR number in the target repo
sha: Commit SHA
allow_infra_issues: Whether to allow creating infrastructure issues
Returns:
tuple: (known_failures, unknown_failures, not_finished_jobs, issues_created_count)
"""
... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>#!/usr/bin/env python3
"""
Script to check mypy errors on files changed from the last common ancestor with master.
Compares mypy errors between the base branch (master) and the current branch.
"""
import os
import re
import subprocess
import sys
import tempfile
from dataclasses import dataclass
from pat... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> return response.text
else:
print(f"WARNING: CIDB query failed: {response.text}")
if response.status_code >= 500:
time.sleep(2**retry) # exponential backoff
continue
else:
... | fim | ClickHouse/ClickHouse | python |
import glob
import json as json_module
import os
import platform
import signal
import subprocess
import sys
import time
import threading
import traceback
import uuid
from collections import defaultdict
from pathlib import Path
from typing import List
from ci.jobs.scripts.clickhouse_service import ClickHouseService
fro... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import os
import shlex
import shutil
import signal
import subprocess
import time
import urllib.request
from pathlib<|fim_suffix|>onfig.xml", "users.xml"):
shutil.copy(src_dir / name, config_dir / name)
shutil.copytree(
src_dir / "config.d",
confi... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import re
from pathlib import Path
from ci.praktika.info import Info
from ci.praktika.utils import Shell
class CHVersion:
FILE_WITH_VERSION_PATH = "./cmake/autogenerated_versions.txt"
VERSIONS_TEMPLATE = """\
# Autogenerated code
SET(VERSION_REVISION {revision})
SET(VERSION_MAJOR {major})
SET(... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>rrent_section
)
return (
total_sections,
total_fn_found_before,
total_fn_hit_before,
total_fn_found_after,
total_fn_hit_after,
)
def main():
if len(sys.argv) < 2:
print(f"Usage: {sys.argv[0]} input.info [output.info]", file=sys.std... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>and isinstance(
DOCKER_TAG, str
), "DOCKER_TAG env must be provided"
if "{" in DOCKER_TAG:
tags_map = json.loads(DOCKER_TAG)
assert (
image_name in tags_map
), f"Image name [{image_name}] does not exist in provided DOCKER_TAG ... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> one-way copy from {owner}{where}.")
if src.get("url"):
lines.append(f" Canonical source: {src['url']}")
lines.append(
" Edit it there -- changes made directly here are overwritten by the "
"next sync."
)
lines.append(" Offending files... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>#!/usr/bin/env python3
"""
Run the Mintlify docs checks for a slice of a larger docs site.
Run this inside the docs image (``clickhouse/docs-builder``), which provides
``mint`` along with ``git`` and ``python3``; nothing is installed locally. A
consuming repo vendors nothing -- its CI runs the image as t... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>#!/usr/bin/env python3
import dataclasses
import json
import sys
from datetime import datetime, timedelta
sys.path.append(".")
from ci.praktika.utils import Shell
REPOS = [
"ClickHouse/ClickHouse",
"ClickHouse/ClickHouse-private",
]
INTERVAL_DAYS = 7
@dataclasses.dataclass
class PullRequest:... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>#!/usr/bin/env python3
import argparse
import io
import subprocess
import sys
import time
import urllib.request
from pathlib import Path
class DiffToSymbols:
def __init__(self, clickhouse_path: str, pr_number: int):
if Path(clickhouse_path).is_dir():
self.clickhouse_path = clickh... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from ci.jobs.scripts.cidb_cluster import CIDBCluster
from ci.jobs.scripts.clickhouse_proc import ClickHouseProc
from ci.praktika.utils import Shell, Utils
temp_dir = f"{Utils.cwd()}/ci/tmp"
class CoverageExporter:
LOGS_SAVER_CLIENT_OPTIONS = "--max_memory_usage 10G --max_threads 1 --max_result_rows... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import dataclasses
import re
import runpy
import signal
import traceback
from pathlib import Path
from typing import List, Optional
from praktika.result import Result
OK_SIGN = "[ OK "
FAIL_SIGN = "[ FAIL "
UNKNOWN_SIGN = "[ UNKNOWN "
SKIPPED_SIGN = "[ SKIPPED "
NOT_FAILED_SIGN = "[ NOT_FAILED "
HUNG_SI... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>#!/usr/bin/env python3
import itertools
import os
from argparse import ArgumentParser
import jinja2
def removesuffix(text, suffix):
"""
Added in python 3.9
https://www.python.org/dev/peps/pep-0616/
"""
if s<|fim_suffix|>r.parse_args())
<|fim_middle|>uffix and text.endswith(suffix):... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>#!/usr/bin/env python3
"""Post-hook script: ingest keeper_metrics.jsonl into CIDB after a keeper stress job."""
import os
import sys
from pathlib import Path
_repo_dir = str(Path(__file__).resolve().parents[3])
_ci_dir = str(Path(__file__).resolve().parents[2])
for _p in (_repo_dir, _ci_dir):
if _p n... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import dataclasses
import traceback
from ci.jobs.scripts.cidb_cluster import CIDBCluster
from ci.praktika.info import Info
@dataclasses.dataclass
class TC:
prefix: str
is_sequential: bool
comment: str
# Tests that are too slow to run under LLVM coverage instrumentation.
# They either time... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import traceback
from ci.defs.defs import S3_BUCKET_NAME, BuildTypes
from ci.praktika.info import Info
from ci.praktika.s3 import S3
from ci.praktika.utils import Shell
BUILD_TYPE_TO_STATIC_LOCATION = {
BuildTypes.AMD_RELEASE: "amd64",
Bu<|fim_suffix|> BuildTypes.AMD_FREEBSD: "freebsd",
Bui... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>t applicable for PRs")
<|fim_prefix|>import sys
import traceback
from pathlib import Path
from ci.jobs.scripts.log_cluster import LogClusterBuildP<|fim_middle|>rofileQueries
from ci.praktika.info import Info
from ci.praktika.result import Result
from ci.praktika.utils import Shell, Utils
temp_dir = "./c... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>eanup"],
check=False,
)
<|fim_prefix|>"""Post-hook: kill any test processes that outlived fast_test.py.
fast_test.py normally invokes `clickhouse-test --cleanup` in its finally block.
But if fast_test.py itself is killed with SIGKILL (e.g. OOM), that block never
runs. This hook calls `clickhouse-tes... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from ci.praktika.utils import Shell
def check():
print(
"Remove all images with names starting with clickhouse/clickhouse- or clickhouse/install- (forced)"
)
Shell.check(
"docker images --format '{{.Repository}}:{{.Tag}}' | grep -E '^clickhouse/(clickhouse|install)-' | xargs ... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>
import sys
from pathlib import Path
repo_path = Path(__file__).resolve().parent.parent.parent.parent.parent
sys.path.append<|fim_suffix|>s import Shell
Shell.run("docker ps -a; docker container prune -f; docker volume prune -f --all; docker system df")
<|fim_middle|>(str(repo_path))
from ci.praktika.ut... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> "baseline_line_cov": b_line_cov,
"baseline_func_cov": b_function_cov,
"baseline_branch_cov": b_branch_cov,
"current_line_cov": c_line_cov,
"current_func_cov": c_function_cov,
"current_branch_cov": c_branch_cov,
... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>e has non-finite 'pct'; skip comment"
)
return
delta = new_pct - base_pct
if abs(delta) < EPS:
print("PromQL compliance hook: delta vs baseline is ~0, skip comment")
return
dp = new_pct - base_pct
d_passed = cur_passed - base_passed
d_failed = cur_fail... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>anch or "").strip() == MASTER_BRANCH
and (info.repo_name or "").strip() == UPSTREAM_REPO
)
<|fim_prefix|>"""S3 baseline for PromQL compliance (same layout idea as LLVM coverage .info).
Master publishes to (HTTPS, public read):
https://clickhouse-builds.s3.amazonaws.com/REFs/master/<sha>/pro... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import time
import traceback
import requests
from ci.praktika.info import Info
from ci.praktika.secret import Secret
class LogCluster:
URL_SECRET = "clickhouse_ci_logs_host"
PASSWD_SECRET = "clickhouse_ci_logs_password"
USER = "ci"
def __init__(self):
self.user = "ci"
<|... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>lt_name, info, files = FTG.parse_failure()
print("Result name:", result_name)
print("Info:\n", info)
<|fim_prefix|>import re
import string
import sys
sys.path.append(".")
from ci.praktika.utils import Shell
class FuzzerLogParser:
UNKNOWN_ERROR = "Unknown error"
MAX_INLINE_REPRODUCE_COMM... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>hmarks tr :nth-child(2),
.concurrent-benchmarks tr :nth-child(3),
.concurrent-benchmarks tr :nth-child(4),
.concurrent-benchmarks tr :nth-child(5),
.metric-changes tr :nth-child(2),
.metric-changes tr :nth-child(3),
.metric-changes tr :nth-child(4),
.metric-changes tr :nth-child(5)
{{ text-align: right; }... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>"""Find code that is newly covered by the tests added/modified in this PR.
For a tests-only PR the global coverage delta is too small to be informative
(a single new test rarely shifts overall coverage by more than 0.01 pp).
What is actually informative is: "which previously-uncovered lines/functions
bec... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>t, prev))
start = prev = ln
ranges.append((start, prev))
return ranges
print("=" * 80)
print("Changed-lines coverage summary")
print("=" * 80)
print(
"Denominator: lines added/modified by this PR in C/C++ source files that "
"LCOV considers ... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> i += 1
continue
# Collect unknown lines
unknown_lines.append(line)
i += 1
for error in errors_before_trace + errors_after_trace:
for idx, line in enumerate(error):
if "<Fatal>" in line:
error... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>ures `hung_check.log` can be very large (a
# full processlist plus a `gdb` backtrace for every server
# process), and the stress-test machine is already under
# memory pressure. The diagnostic content we need
# (`Found hung queries`, the proc... | fim | ClickHouse/ClickHouse | python |
import sys
from ci.jobs.scripts.workflow_hooks.pr_labels_and_category import Labels
from ci.praktika.info import Info
def check():
info = Info()
forbidden_labels = [
Labels.CI_PERFORMANCE,
Labels.NO_FAST_TESTS,
Labels.CI_INTEGRATION_FLAKY,
Labels.CI_FUNCTIONAL_FLAKY,
L... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import sys
from ci.praktika.info import Info
from ci.praktika.utils import Shell
if __name__ == "__main__":
info = Info()
if info.workflow_name == "BackportPR":
assert info.base_branch
# Ensure base branch is fetched.
# We use treeless fetch (--filter=tree:0) and no-tags ... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>ME, status=Result.Status.FAIL, description=description, url=""
)
except Exception as e:
print(f"WARNING: check_report_messages failed: {e}")
if __name__ == "__main__":
check()
<|fim_prefix|>"""
Workflow hook that posts a GH commit status summarising errors and warnings
from t... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import sys
import time
import traceback
from praktika.info import Info
from praktika.utils import Shell
SYNC_REPO = "ClickHouse/clickhouse-private"
def check():
info = Info()
if not info.linked_pr_number > 0:
print(f"WARNING: Invalid or unknown pr number: {info.linked_pr_number}")
... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import sys
from praktika.info import Info
from c<|fim_suffix|>ings.h",
]
def file_contains_marker(file_path, marker):
"""Check if a file contains the given marker string."""
try:
with open(file_path) as f:
content = f.read()
return marker in content
except OSErr... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import re
from ci.defs.defs import JobNames
from ci.defs.job_configs import JobConfigs
from ci.jobs.scripts.workflow_hooks.new_tests_check import (
has_new_functional_tests,
has_new_integration_tests,
)
from ci.jobs.scripts.workflow_hooks.pr_labels_and_category import Labels
from ci.praktika.info... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import traceback
from praktika.info import Info
from praktika.utils import Shell
SYNC_REPO = "ClickHouse/clickhouse-private"
def check():
info = Info()
if not info.linked_pr_number > 0:
print(f"WARNING: Invalid or unknown pr number: {info.linked_pr_number}")
return
sync_p... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import sys
from pathlib import Path
from ci.praktika.gh import GH
from ci.praktika.info import Info
def has_new_functional_tests(changed_files):
for file in changed_files:
file = file.removeprefix(".").removeprefix("/")
# Deleted files are still listed in changed_files; skip them so... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import re
import sys
from ci.jobs.scripts.workflow_hooks.pr_labels_and_category import (
BOT_AUTHORS,
NO_CHANGELOG_REQUIRED_LABELS,
find_category,
get_category,
)
from ci.praktika.gh import GH
from ci.praktika.info import Info
def check_changelog_entry(category, pr_body: str) -> str:
... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>d allows normalized Levenshtein distance up to 20%
(with whitespace removed for comparison).
Returns (matched_category, label) or (None, None).
"""
# Exact match
if category in CATEGORY_TO_LABEL:
return category, CATEGORY_TO_LABEL[category]
# Normalized exact match
no... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import shlex
import sys
import traceback
from ci.defs.defs im<|fim_suffix|>om ci.praktika.gh import GH
from ci.praktika.info import Info
from ci.praktika.result import Result
from ci.praktika.utils import Shell
def check():
info = Info()
if info.user_name not in ("yariks5s", "maxknv"):
... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from praktika.gh import GH
from praktika.result import Result
# Sets dummy commit status for "CH Inc Sync" in the Merge Queue workflow
SYNC = "CH Inc sync"
if __name__ == "__main__":
GH.post_commi<|fim_suffix|> name=SYNC, status=Result.Status.OK, description="dummy status to enable merge", url="... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> print(
f"Failed to get PR number from commit message [{commit_message}]: {e}"
)
<|fim_prefix|>import re
from ci.praktika.info import Info
if __name__ == "__main__":
info = Info()
if info.pr_number == 0:
# Extract original PR number from b... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import copy
from ci.defs.job_configs import JobConfigs
from ci.jobs.scripts.clickhouse_version import CHVersion
from ci.praktika.digest import Digest
from ci.praktika.gh import GH
from ci.praktika.info import Info
from ci.praktika.utils import Shell
if __name__ == "__main__":
info = Info()
# st... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import sys
from ci.praktika.gh import GH
from ci.praktika.info import Info
integrations_ecosystem_files = ["src/Core/TypeId.h"]
def check():
info = Info()
changed_files = info.get_kv_data("changed_files")
assert changed_files is not None, (
"changed_files is not populated in JOB_K... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import s<|fim_suffix|>16, remove by 05/2026
]
}
CAN_BE_TESTED = "can be tested"
def user_in_trusted_org(user_name: str) -> bool:
"""Check if the user is in a trusted organization."""
lines = Shell.get_output(
"gh api orgs/ClickHouse/members --paginate --cache=1h --jq='.[].login'",
... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|>ion_history()
<|fim_prefix|>from datetime import datetime
from praktika.info import Info
from praktika.utils import Shell
from ci.jobs.scripts.cidb_cluster import CIDBCluster
from ci.jobs.scripts.clickhouse_version import CHVersion
def _add_build_to_version_history():
info = Info()
Shell.check... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> test_results.append(
Result.create_from(
name="Start server",
status=Result.Status.OK,
info="Server started successfully",
)
)
server_started = True
else:
# Collect err... | fim | ClickHouse/ClickHouse | python |
<|fim_suffix|> == "1":
print("Server ready")
break
else:
print("Server not ready, wait")
Utils.sleep(delay)
else:
Utils.print_formatted_error(
f"Server not ready after [{attempts*delay}s]", out, err
)... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>#!/usr/bin/env python3
import html
import os
import random
import string
import subprocess
import time
from pathlib import Path
import yaml
from clickhouse_driver import Client
from praktika.result import Result
from praktika.utils import Shell, Utils
temp_dir = f"{Utils.cwd()}/ci/tmp/"
# TODO: gener... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import csv
import logging
import os
import sys
from pathlib import Path
from typing import List, Tuple
from ci.jobs.scripts.clickhouse_service import ClickHouseService
from ci.jobs.scripts.docker_image import DockerImage
from ci.jobs.scripts.log_parser import FuzzerLogParser
from ci.praktika.info import ... | fim | ClickHouse/ClickHouse | python |
import argparse
import os
from ci.praktika.info import Info
from ci.praktika.result import Result
from ci.praktika.utils import Shell
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--gtest_filter", default="")
args = parser.parse_args()
# The CI Docker image instal... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>import re
import shlex
from praktika._environment import _Environment
from praktika.result import Result
from praktika.utils<|fim_suffix|> - aarch64: {arm_url}
### Changelog category (leave one):
- Build/Testing/Packaging Improvement
### Changelog entry (a [user-readable short description](https://git... | fim | ClickHouse/ClickHouse | python |
<|fim_prefix|>from ci.jobs.stress_job import run_stress_test
if __name__ == "__main__":
run_st<|fim_suffix|>True)
<|fim_middle|>ress_test(upgrade_check=<|endoftext|> | fim | ClickHouse/ClickHouse | python |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.