/usr/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 you can execute your SQL queries in usual manner.
There are two ways to define initial table keeping your data. Either just in 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 synchonously
  --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'
  --echo            In batch mode, print query before
                    execution
  --log-level arg   Log level
  --server_logs_file arg
                    Write server logs to specified file
  -f [ --format ] arg
                    Default output format (and input format
                    for clickhouse-local)
  --output-format arg
                    Default output format (this option has
                    preference over --format)
  -E [ --vertical ]
                    Vertical output format, same as
                    --format=Vertical or FORMAT Vertical or
                    \G at end of command
  --highlight arg (=1)
                    Toggle syntax highlighting in
                    interactive mode (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
                    input format of the initial table data
  --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

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/