/opt/iamguarded/clickhouse/bin/chl

Usage: clickhouse local [initial table definition] [--query <query>]

clickhouse local allows to execute SQL queries on your data files
via single command line call.
To do so, initially you need to define your data source and its format.
After that, you can execute your SQL queries as usual.

There are two ways to define initial table keeping your data.
Either just in the first query like this:
    CREATE TABLE <table> (<structure>) ENGINE = File(<input-format>, <file>);
Either through corresponding command line parameters
--table --structure --input-format and --file.
Main options:
  --help            Print usage summary and exit; combine
                    with --verbose to display all options
  --verbose         Increase output verbosity
  -V [ --version ]  Print version and exit
  --version-clean   Print version in machine-readable
                    format and exit
  -C [ --config-file ] arg
                    Path to config file
  --proto_caps arg  Enable/disable chunked protocol:
                    chunked_optional, notchunked,
                    notchunked_optional, send_chunked,
                    send_chunked_optional, send_notchunked,
                    send_notchunked_optional, recv_chunked,
                    recv_chunked_optional, recv_notchunked,
                    recv_notchunked_optional
  -q [ --query ] arg
                    Query. Can be specified multiple times
                    (--query "SELECT 1" --query "SELECT 2")
                    or once with multiple
                    semicolon-separated queries (--query
                    "SELECT 1; SELECT 2;"). In the latter
                    case, INSERT queries with non-VALUE
                    format must be separated by empty
                    lines.
  --queries-file arg
                    File path with queries to execute;
                    multiple files can be specified
                    (--queries-file file1 file2...)
  -n [ --multiquery ]
                    Obsolete, does nothing
  -m [ --multiline ]
                    If specified, allow multi-line queries
                    (Enter does not send the query)
  -d [ --database ] arg
                    Database
  --query_kind arg (=initial_query)
                    One of initial_query/secondary_query/no
                    _query
  --query_id arg    Query ID
  --history_file arg
                    Path to a file containing command
                    history
  --history_max_entries arg (=1000000)
                    Maximum number of entries in the
                    history file
  --stage arg (=complete)
                    Request query processing up to
                    specified stage: complete,fetch_columns
                    ,with_mergeable_state,with_mergeable_st
                    ate_after_aggregation,with_mergeable_st
                    ate_after_aggregation_and_limit
  --progress [=arg(=tty)] (=default)
                    Print progress of queries execution -
                    to TTY: tty|on|1|true|yes; to STDERR
                    non-interactive mode: err; OFF:
                    off|0|false|no; DEFAULT - interactive
                    to TTY, non-interactive is off
  --progress-table [=arg(=tty)] (=default)
                    Print a progress table with changing
                    metrics during query execution - to
                    TTY: tty|on|1|true|yes; to STDERR
                    non-interactive mode: err; OFF:
                    off|0|false|no; DEFAULT - interactive
                    to TTY, non-interactive is off
  --enable-progress-table-toggle arg (=1)
                    Enable toggling of the progress table
                    by pressing the control key (Space).
                    Only applicable in interactive mode
                    with the progress table enabled.
  -A [ --disable_suggestion ]
                    Disable loading suggestions. Note that
                    suggestions are loaded asynchronously
                    through a second connection to
                    ClickHouse server. Recommended when
                    pasting queries with TAB characters.
  --wait_for_suggestions_to_load
                    Load suggestion data synchronously
  --suggestion_limit arg (=10000)
                    Suggestion limit for how many
                    databases, tables and columns to fetch
  -t [ --time ]     Print query execution time to stderr in
                    non-interactive mode (for benchmarks)
  --memory-usage [=arg(=default)] (=none)
                    Print memory usage to stderr in
                    non-interactive mode (for benchmarks).
                    Values: 'none', 'default', 'readable'
  --chime [=arg(=5)] (=5)
                    Emit the ASCII `BEL` control character
                    (`\x07`) to stderr when a query
                    finishes (on success and on error)
                    after running for at least this many
                    seconds. Useful to alert when a
                    long-running query completes. Default:
                    5 seconds (also used when `--chime` is
                    passed without a value). Pass `--chime
                    0` to disable. Only emitted when stderr
                    is attached to a terminal; redirected
                    stderr (file, pipe) is left untouched.
                    Whether the terminal makes a sound or
                    visual flash depends on the terminal's
                    user preferences.
  --echo [=arg(=1)] Print queries before execution. Enabled
                    by default in interactive mode,
                    disabled in batch mode.
  --echo-formatted [=arg(=1)]
                    Format the echoed queries. Enabled by
                    default in interactive mode, disabled
                    in batch mode.
  --echo-query-id [=arg(=1)]
                    Print the query_id before execution.
                    Enabled by default in interactive mode,
                    disabled in batch mode.
  --log-level arg   Log level
  --server_logs_file arg
                    Write server logs to specified file
  -f [ --format ] arg
                    Default input and output format. In
                    clickhouse-client only the default
                    output format.
  --output-format arg
                    Default output format. Takes precedence
                    over --format.
  -E [ --vertical ]
                    Same as --format=Vertical or FORMAT
                    Vertical or \G at end of command
  --highlight arg (=1)
                    Toggle syntax highlighting of the
                    command prompt and the echoed queries
                    (can also use --hilite)
  --ignore-error    Do not stop processing after an error
                    occurred
  --stacktrace      Print stack traces of exceptions
  --hardware-utilization
                    Print hardware utilization information
                    in progress bar
  --print-profile-events
                    Printing ProfileEvents packets
  --profile-events-delay-ms arg (=0)
                    Delay between printing `ProfileEvents`
                    packets (-1 - print only totals, 0 -
                    print every single packet)
  --processed-rows  Print the number of locally processed
                    rows
  --interactive     Process queries-file or --query query
                    and start interactive mode
  --pager arg       Pipe all output into this command (less
                    or similar)
  --prompt arg      Custom prompt string
  --max_memory_usage_in_client arg
                    Set memory limit in client/local server
  --client_logs_file arg
                    Path to a file for writing client logs.
                    Currently we only have fatal logs (when
                    the client crashes)
  -N [ --table ] arg
                    Name of the initial table
  --copy            Shortcut for format conversion,
                    equivalent to: --query 'SELECT * FROM
                    table'
  -S [ --structure ] arg
                    Structure of the initial table (list of
                    column and type names)
  -F [ --file ] arg Path to file with data of the initial
                    table (stdin if not specified)
  --input-format arg
                    Default input format. Takes precedence
                    over --format.
  --logger.console [=arg(=1)]
                    Log to console
  --logger.log arg  Log file name
  --logger.level arg
                    Log level
  --no-system-tables
                    Do not attach system tables (better
                    startup time)
  --path arg        Storage path. If it was not specified,
                    we will use a temporary directory, that
                    is cleaned up on exit.
  --only-system-tables
                    Attach only system tables from
                    specified path
  --top_level_domains_path arg
                    Path to lists with custom TLDs
  --listen_host arg Host to listen on for SYSTEM START
                    LISTEN (default: ::1 and 127.0.0.1)
  --tcp_port arg    Port for native TCP protocol (default:
                    9000)
  --http_port arg   Port for HTTP protocol (default: 8123)

All settings are documented at https://clickhouse.com/docs/operations/settings/settings.

Example printing memory used by each Unix user:
    ps aux | tail -n +2 | awk '{ printf("%s\t%s\n", $1, $4) }' | \
        clickhouse local -S "user String, mem Float64" -q \
        "SELECT user, round(sum(mem), 2) as mem_total FROM table \
         GROUP BY user ORDER BY mem_total DESC FORMAT PrettyCompact"
In addition, --param_name=value can be specified for substitution of parameters for parameterized queries.

See also: https://clickhouse.com/docs/en/operations/utilities/clickhouse-local/