clickhouse輸入/輸出（導入/導出）數據格式

　　　ClickHouse可以接受和返回各種格式的數據。受支持的輸入格式可用於提交給INSERT語句、從文件表(File,URL,HDFS或者外部目錄)執行SELECT語句，受支持的輸出格式可用於格式化SELECT語句的返回結果，或者通過INSERT寫入到文件表。

以下是支持的格式:

格式	輸入	輸出
TabSeparated	✔	✔
TabSeparatedRaw	✔	✔
TabSeparatedWithNames	✔	✔
TabSeparatedWithNamesAndTypes	✔	✔
Template	✔	✔
TemplateIgnoreSpaces	✔	✗
CSV	✔	✔
CSVWithNames	✔	✔
CustomSeparated	✔	✔
Values	✔	✔
Vertical	✗	✔
JSON	✗	✔
JSONAsString	✔	✗
JSONStrings	✗	✔
JSONCompact	✗	✔
JSONCompactStrings	✗	✔
JSONEachRow	✔	✔
JSONEachRowWithProgress	✗	✔
JSONStringsEachRow	✔	✔
JSONStringsEachRowWithProgress	✗	✔
JSONCompactEachRow	✔	✔
JSONCompactEachRowWithNamesAndTypes	✔	✔
JSONCompactStringsEachRow	✔	✔
JSONCompactStringsEachRowWithNamesAndTypes	✔	✔
TSKV	✔	✔
Pretty	✗	✔
PrettyCompact	✗	✔
PrettyCompactMonoBlock	✗	✔
PrettyNoEscapes	✗	✔
PrettySpace	✗	✔
Protobuf	✔	✔
ProtobufSingle	✔	✔
Avro	✔	✔
AvroConfluent	✔	✗
Parquet	✔	✔
Arrow	✔	✔
ArrowStream	✔	✔
ORC	✔	✔
RowBinary	✔	✔
RowBinaryWithNamesAndTypes	✔	✔
Native	✔	✔
Null	✗	✔
XML	✗	✔
CapnProto	✔	✗
LineAsString	✔	✗
Regexp	✔	✗
RawBLOB	✔	✔

TabSeparated 

　　在TabSeparated分隔格式中，數據按行寫入。每行包含由制表符分隔的值，每個值后跟一個制表符，除了行中最后一個值，最后的值后面是一個換行符。在任何地方都采用嚴格的Unix換行(\n)。最后一行結束后必須再插入一個換行符。值以文本格式編寫，不包含引號，並使用轉義的特殊字符。

　　這種格式也被稱為TSV。

　　TabSeparated格式便於其他的程序和腳本處理數據。默認情況下，HTTP接口和命令行客戶端的批處理模式中會使用這個格式。這種格式還允許在不同dbms之間傳輸數據。例如，您可以從MySQL獲取轉儲並將其上傳到ClickHouse，反之亦然。

　　TabSeparated格式支持輸出總計的結果(當SQL語句包含WITH TOTALS)和極值(當extremes被設置為1時)。在這種情況下，總計值和極值會在主數據后輸出。主要結果、總值和極值之間用空行分隔。示例:

set extremes=1;
SELECT EventDate, count() AS c FROM test.hits_v1 GROUP BY EventDate WITH TOTALS ORDER BY EventDate FORMAT TabSeparated;

2014-03-17      1406958
2014-03-18      1383658
2014-03-19      1405797
2014-03-20      1353623
2014-03-21      1245779
2014-03-22      1031592
2014-03-23      1046491

0000-00-00      8873898

2014-03-17      1031592
2014-03-23      1406958

數據格式化 

　　整數是用十進制形式寫的。數字可以在開頭包含一個額外的+字符(解析時忽略該符號，格式化時不記錄該符號)。非負數不能包含負號。在讀取時，允許將空字符串解析為零，或者(對於有符號類型)將'-'(僅有減號的字符串)解析為零。不符合相應數據類型的數字可能被解析為數值，而不會出現錯誤消息。

　　浮點數以十進制形式書寫。用.作為小數點的符號。支持指數符號，如inf、+inf、-inf和nan。小數點前或后可以不出現數字(如123.或.123)。在格式化期間，浮點數精度可能會丟失。在解析期間，並不嚴格要求讀取與機器可以表示的最接近的數值。

　　日期以YYYY-MM-DD格式編寫，並以相同的格式解析，但允許使用任何字符作為分隔符。日期和時間以YYYY-MM-DD hh:mm:ss的格式書寫，並以相同的格式解析，但允許使用任何字符作為分隔符。時區采用客戶端或服務器端時區(取決於誰對數據進行格式化)。對於帶有時間的日期，沒有是哦用夏時制時間。因此，如果導出的數據采用了夏時制，則實際入庫的時間不一定與預期的時間對應，解析將根據解析動作發起方選擇時間。在讀取操作期間，不正確的日期和具有時間的日期可以自然溢出(如2021-01-32)或設置成空日期和時間，而不會出現錯誤消息。

有個例外情況，時間解析也支持Unix時間戳(如果它恰好由10個十進制數字組成)。其結果與時區無關。格式YYYY-MM-DD hh:mm:ss和NNNNNNNNNN這兩種格式會自動轉換。

　　字符串輸出時，特殊字符會自動轉義。以下轉義序列用於輸出:\b, \f, \r, \n, \t, \0, \', \\。解析還支持\a、\v和\xHH(HH代表十六進制編碼)和\c，其中c是任何字符(這些序列被轉換為c)。因此，讀取數據時，換行符可以寫成\n或\。例如，如果要表示字符串Hello world中'Hello'與'world'中間的空格實際上是個換行符，可以寫成下面的形式:

Hello\nworld
--等同於


Hello\
world

　　第二種形式也受支持，因為MySQL導出tab-separated格式的數據時使用這種格式。使用TabSeparated格式傳遞數據時至少需要轉義以下特殊字符:制表符(\t)、換行符(\n)和反斜杠(\)。只有一小部分符號被轉義。您可以很容易地找到一個能夠破壞命令行終端輸出的特殊字符。

　　數組用方括號包裹、逗號分隔的形式表示(例如[11,22,33])。數組中的數字項按上述規則進行格式化。日期和日期時間類型用單引號包裹。字符串用單引號包裹，遵循上述轉義規則。NULL將輸出為\N。Nested結構的每個元素都表示為數組。

　　示例：

CREATE TABLE nestedt
(
    `id` UInt8,
    `aux` Nested(
        a UInt8,
        b String
    )
)
ENGINE = TinyLog

INSERT INTO nestedt Values ( 1, [1], ['a'])

SELECT * FROM nestedt FORMAT TSV

1  [1]    ['a']

 

TabSeparatedRaw 

　　與TabSeparated格式的不同之處在於，寫入的數據不會進行轉義處理。使用這種格式解析時，每個字段中不允許出現制表符或換行符。這種格式也被稱為TSVRaw。

TabSeparatedWithNames 

　　不同於TabSeparated，列名會寫在第一行。在解析過程中，第一行被完全忽略。您不能依賴列名來確定它們的位置或檢查它們的正確性。(將來可能會添加對頭行解析的支持。)這種格式也被稱為TSVWithNames。

TabSeparatedWithNamesAndTypes 

　　與TabSeparated格式不同的是列名寫在第一行，而列類型寫在第二行。在解析過程中，將完全忽略第一行和第二行。這種格式也被稱為TSVWithNamesAndTypes。

Template 

　　此格式允許指定帶有占位符的自定義格式字符串，這些占位符用於指定轉義規則。它使用format_schema, format_schema_rows, format_schema_rows_between_delimiter以及其他格式的一些設置(例如轉義JSON時使用output_format_json_quote_64bit_integers，具體請向下閱讀)

設置format_template_row用於指定行格式文件的路徑，該格式文件包含行格式字符串，語法如下:

delimiter_i${column_i:serializeAs_i}delimiter_i${column_i:serializeAs_i} ... delimiter_i,

其中，delimiter_i是各值之間的分隔符($符號可以轉義為$$)，column_i是選擇或插入值的列的名稱或索引(如果為空，則跳過該列)，serializeAs_i是列值的轉義規則。支持以下轉義規則:

• CSV, JSON, XML (類似於相同名稱的格式)
• Escaped (類似於TSV)
• Quoted (類似於Values)
• Raw (不轉義，類似於TSVRaw)
• None (不轉義，具體請向下閱讀)

　　如果省略了轉義規則，那么將使用None。XML和Raw只適用於輸出。

　　對於下面的格式字符串:

 `Search phrase: ${SearchPhrase:Quoted}, count: ${c:Escaped}, ad price: $$${price:JSON};`

　　SearchPhrase、c和price列的值遵循Quoted、Escaped和JSON轉義規則，將分別在Search phrase:， ， count:， ， ad price: $和;分隔符之間打印(用於SELECT)或輸入期望的值(用於INSERT)。例如:

Search phrase: 'bathroom interior design', count: 2166, ad price: $3;format_template_rows_between_delimiter設置指定行之間的分隔符，它將打印(或輸入期望值)在每一行之后，最后一行除外(該設置默認值為\n)。

　　設置format_template_resultset指定結果集格式文件路徑，該文件包含結果集的格式字符串。結果集的格式字符串與上述的行格式字符串具有相同的語法，並允許指定前綴、后綴，還提供打印一些附加信息的方法。該文件使用如下占位符，用於取代行格式字符串的列名的位置(即column_i):

• data 代表遵循format_template_row格式的數據行，由format_template_rows_between_delimiter設置制定的字符分隔。此占位符必須是格式字符串中的第一個占位符。
• totals 代表遵循format_template_row格式的數據行，該行用於代表結果的總計值(當SQL語句包含了WITH TOTALS)
• min 代表遵循format_template_row格式的數據行，該行用於代表結果的最小值(當extremes設置為1時)
• max 代表遵循format_template_row格式的數據行，該行用於代表結果的最大值(當extremes設置為1時)
• rows 代表輸出行的總數
• rows_before_limit 代表沒有LIMIT限制的結果最小行數。僅當查詢包含LIMIT時才輸出此值。如果查詢包含GROUP BY，那么rows_before_limit_at_least就是沒有LIMIT的確切行數。
• time 代表請求執行時間(秒)
• rows_read 代表已讀取的行數
• bytes_read 代表已讀取(未壓縮)的字節數

　　占位符data、totals、min和max不允許指定轉義規則(允許顯式指定None)。其余占位符可以指定任何轉義規則。如果format_template_resultset設置為空，則使用${data}作為默認值。對於insert查詢，格式允許跳過某些列或某些字段的前綴或后綴(參見示例)。

　　Select示例:

SELECT SearchPhrase, count() AS c FROM test.hits GROUP BY SearchPhrase ORDER BY c DESC LIMIT 5 FORMAT Template SETTINGS
format_template_resultset = '/some/path/resultset.format', format_template_row = '/some/path/row.format', format_template_rows_between_delimiter = '\n'  

　　/some/path/resultset.format:

<!DOCTYPE HTML>
<html> <head> <title>Search phrases</title> </head>
 <body>
  <table border="1"> <caption>Search phrases</caption>
    <tr> <th>Search phrase</th> <th>Count</th> </tr>
    ${data}
  </table>
  <table border="1"> <caption>Max</caption>
    ${max}
  </table>
  <b>Processed ${rows_read:XML} rows in ${time:XML} sec</b>
 </body>
</html>

　　/some/path/row.format:

<tr> <td>${0:XML}</td> <td>${1:XML}</td> </tr>

　　結果：

<!DOCTYPE HTML>
<html> <head> <title>Search phrases</title> </head>
 <body>
  <table border="1"> <caption>Search phrases</caption>
    <tr> <th>Search phrase</th> <th>Count</th> </tr>
    <tr> <td></td> <td>8267016</td> </tr>
    <tr> <td>bathroom interior design</td> <td>2166</td> </tr>
    <tr> <td>yandex</td> <td>1655</td> </tr>
    <tr> <td>spring 2014 fashion</td> <td>1549</td> </tr>
    <tr> <td>freeform photos</td> <td>1480</td> </tr>
  </table>
  <table border="1"> <caption>Max</caption>
    <tr> <td></td> <td>8873898</td> </tr>
  </table>
  <b>Processed 3095973 rows in 0.1569913 sec</b>
 </body>
</html>

　　Insert示例：

Some header
Page views: 5, User id: 4324182021466249494, Useless field: hello, Duration: 146, Sign: -1
Page views: 6, User id: 4324182021466249494, Useless field: world, Duration: 185, Sign: 1
Total rows: 2

INSERT INTO UserActivity FORMAT Template SETTINGS
format_template_resultset = '/some/path/resultset.format', format_template_row = '/some/path/row.format'

　　/some/path/resultset.format:

Some header\n${data}\nTotal rows: ${:CSV}\n

　　/some/path/row.format:

Page views: ${PageViews:CSV}, User id: ${UserID:CSV}, Useless field: ${:CSV}, Duration: ${Duration:CSV}, Sign: ${Sign:CSV}

　　PageViews, UserID, Duration和Sign 占位符是表中列的名稱。將忽略行中Useless field后面和后綴中\nTotal rows:之后的值。輸入數據中的所有分隔符必須嚴格等於指定格式字符串中的分隔符。

TemplateIgnoreSpaces 

　　這種格式只適用於輸入。類似於Template，但跳過輸入流中分隔符和值之間的空白字符。但是，如果格式字符串包含空格字符，這些字符將會出現在輸入流中。也允許指定空占位符(${}或${:None})來將一些分隔符分割為單獨的部分，以忽略它們之間的空格。這種占位符僅用於跳過空白字符。
如果列的值在所有行的順序相同，那么可以使用這種格式讀取JSON。可以使用以下請求從格式為JSON的輸出示例中插入數據：

INSERT INTO table_name FORMAT TemplateIgnoreSpaces SETTINGS
format_template_resultset = '/some/path/resultset.format', format_template_row = '/some/path/row.format', format_template_rows_between_delimiter = ','
--/some/path/resultset.format:


{${}"meta"${}:${:JSON},${}"data"${}:${}[${data}]${},${}"totals"${}:${:JSON},${}"extremes"${}:${:JSON},${}"rows"${}:${:JSON},${}"rows_before_limit_at_least"${}:${:JSON}${}}
--/some/path/row.format:


{${}"SearchPhrase"${}:${}${phrase:JSON}${},${}"c"${}:${}${cnt:JSON}${}}

 

TSKV 

　　類似於TabSeparated，但是輸出的值是name=value格式。名稱的轉義方式與TabSeparated格式相同，=符號也會被轉義。

SearchPhrase=   count()=8267016
SearchPhrase=bathroom interior design    count()=2166
SearchPhrase=yandex     count()=1655
SearchPhrase=2014 spring fashion    count()=1549
SearchPhrase=freeform photos       count()=1480
SearchPhrase=angelina jolie    count()=1245
SearchPhrase=omsk       count()=1112
SearchPhrase=photos of dog breeds    count()=1091
SearchPhrase=curtain designs        count()=1064
SearchPhrase=baku       count()=1000
--NULL轉化為\N。


SELECT * FROM t_null FORMAT TSKV

x=1    y=\N

 

　　當有大量的小列時，這種格式效率十分低下，並且通常沒有理由使用它。不過，就效率而言，它並不比JSONEachRow差。這種格式支持數據輸出和解析。用於解析時，可以任意指定列的順序，也可以省略某些列，那些列的值為該列的默認值，一般情況下為0或空白。不支持將可在表中可指定的復雜值設為默認值。解析時允許出現后沒有=的字段tskv。此字段會被忽略。

CSV 

　　按,分隔的數據格式(RFC)。格式化時，每一行的值會用雙引號括起，日期和時間也會以雙引號包括。數字不用雙引號括起，字符串中的雙引號會以兩個雙引號輸出，除此之外沒有其他規則來做字符轉義了。值由分隔符隔開，這個分隔符默認是,。每一行使用Unix換行符(LF,\n)分隔。數組序列化成CSV規則如下：首先將數組序列化為TabSeparated格式的字符串，然后將結果字符串用雙引號括起后輸出到CSV。CSV格式的元組被序列化為單獨的列(即它們在元組中的嵌套關系會丟失)。

$ clickhouse-client --format_csv_delimiter="|" --query="INSERT INTO test.csv FORMAT CSV" < data.csv

　　* 默認情況下分隔符是, ，在format_csv_delimiter中可以了解更多分隔符配置。解析的時候，值可以使用或不使用雙引號或者單引號括起來。在這種情況下，每行通過分隔符或換行符(CR或LF)區分。違反RFC規則的是，在解析未用引號括起的行時，會忽略前綴和結尾的空格和制表符。對於換行符，Unix(LF,\n)，Windows(CR LF\r\n)和Mac OS Classic(CR LF\t\n)都受支持。如果啟用input_format_defaults_for_omitted_fields，對應列如果存在未輸入的空白，且沒有用雙引號括起，將用默認值替換。NULL被格式化為\N或NULL或一個不是引號的其他字符串(詳見配置input_format_csv_unquoted_null_literal_as_null或input_format_defaults_for_omitted_fields)。CSV格式支持輸出總數和極值的方式與TabSeparated相同。

CSVWithNames 

　　會輸出帶頭部的信息(字段列表)，和TabSeparatedWithNames一樣。

CustomSeparated 

　　類似於Template， 但它打印或讀取所有列，並使用設置format_custom_escaping_rule和分隔符設置format_custom_field_delimiter,format_custom_row_before_delimiter,format_custom_row_after_delimiter,format_custom_row_between_delimiter,format_custom_result_before_delimiter,format_custom_result_after_delimiter的轉義規則,而不是從格式字符串。也有CustomSeparatedIgnoreSpaces格式，這個類似於TemplateIgnoreSpaces。

JSON 

　　以JSON格式輸出數據。除了數據表之外，它還輸出列名和類型，以及一些附加信息: 輸出行的總數，以及如果沒有LIMIT的話可輸出的行數。

　　示例:

SELECT SearchPhrase, count() AS c FROM test.hits GROUP BY SearchPhrase WITH TOTALS ORDER BY c DESC LIMIT 5 FORMAT JSON

{
        "meta":
        [
                {
                        "name": "'hello'",
                        "type": "String"
                },
                {
                        "name": "multiply(42, number)",
                        "type": "UInt64"
                },
                {
                        "name": "range(5)",
                        "type": "Array(UInt8)"
                }
        ],

        "data":
        [
                {
                        "'hello'": "hello",
                        "multiply(42, number)": "0",
                        "range(5)": [0,1,2,3,4]
                },
                {
                        "'hello'": "hello",
                        "multiply(42, number)": "42",
                        "range(5)": [0,1,2,3,4]
                },
                {
                        "'hello'": "hello",
                        "multiply(42, number)": "84",
                        "range(5)": [0,1,2,3,4]
                }
        ],

        "rows": 3,

        "rows_before_limit_at_least": 3
}

 

　　JSON與JavaScript兼容。為了確保這一點，一些字符被另外轉義：斜線/被轉義為\/; 換行符U+2028和U+2029會打斷一些瀏覽器的解析，它們會被轉義為\uXXXX。 ASCII控制字符被轉義：退格，換頁，換行，回車和制表符被轉義為\b，\f，\n，\r，\t。剩下的0x00-0x1F被轉義成相應的\uXXXX序列。 無效的UTF-8序列替換為字符�，使得輸出文本包含有效的UTF-8序列。 為了與JavaScript兼容，默認情況下，Int64和UInt64整數用雙引號引起來。要除去引號，可以將配置參數output_format_json_quote_64bit_integers設置為0。

　　rows代表結果輸出的行數。rows_before_limit_at_least代表去掉LIMIT過濾后的最小行總數。只會在查詢包含LIMIT條件時輸出。若查詢包含 GROUP BY，rows_before_limit_at_least就是去掉LIMIT后過濾后的准確行數。totals – 總值 (當指定WITH TOTALS時)。extremes – 極值(當extremes設置為1時)。該格式僅適用於輸出查詢結果，但不適用於解析輸入(將數據插入到表中)。

　　ClickHouse支持NULL, 在JSON輸出中顯示為null。若要在輸出中啟用+nan、-nan、+inf、-inf值，請設置output_format_json_quote_denormals為1。

　　參考　　

• JSONEachRow格式
• output_format_json_array_of_rows設置

JSONStrings 

　　與JSON的不同之處在於數據字段以字符串輸出，而不是以類型化JSON值輸出。

　　示例：

{
        "meta":
        [
                {
                        "name": "'hello'",
                        "type": "String"
                },
                {
                        "name": "multiply(42, number)",
                        "type": "UInt64"
                },
                {
                        "name": "range(5)",
                        "type": "Array(UInt8)"
                }
        ],

        "data":
        [
                {
                        "'hello'": "hello",
                        "multiply(42, number)": "0",
                        "range(5)": "[0,1,2,3,4]"
                },
                {
                        "'hello'": "hello",
                        "multiply(42, number)": "42",
                        "range(5)": "[0,1,2,3,4]"
                },
                {
                        "'hello'": "hello",
                        "multiply(42, number)": "84",
                        "range(5)": "[0,1,2,3,4]"
                }
        ],

        "rows": 3,

        "rows_before_limit_at_least": 3
}

　　注意range(5)的值。

JSONAsString 

　　在這種格式中，一個JSON對象被解釋為一個值。如果輸入有幾個JSON對象(逗號分隔)，它們將被解釋為獨立的行。這種格式只能針對有一列類型為String的表。表中其余的列必須設置為DEFAULT或MATERIALIZED，或者忽略。一旦將整個JSON對象收集為字符串，就可以使用JSON函數運行它。

示例

--查詢：
DROP TABLE IF EXISTS json_as_string;
CREATE TABLE json_as_string (json String) ENGINE = Memory;
INSERT INTO json_as_string FORMAT JSONAsString {"foo":{"bar":{"x":"y"},"baz":1}},{},{"any json stucture":1}
SELECT * FROM json_as_string;
--結果：

┌─json──────────────────────────────┐
│ {"foo":{"bar":{"x":"y"},"baz":1}} │
│ {}                                │
│ {"any json stucture":1}           │
└───────────────────────────────────┘

JSONCompact 

JSONCompactStrings 

　　與JSON格式不同的是它以數組的方式輸出結果，而不是以結構體。

　　示例：

// JSONCompact
{
        "meta":
        [
                {
                        "name": "'hello'",
                        "type": "String"
                },
                {
                        "name": "multiply(42, number)",
                        "type": "UInt64"
                },
                {
                        "name": "range(5)",
                        "type": "Array(UInt8)"
                }
        ],

        "data":
        [
                ["hello", "0", [0,1,2,3,4]],
                ["hello", "42", [0,1,2,3,4]],
                ["hello", "84", [0,1,2,3,4]]
        ],

        "rows": 3,

        "rows_before_limit_at_least": 3
}

// JSONCompactStrings
{
        "meta":
        [
                {
                        "name": "'hello'",
                        "type": "String"
                },
                {
                        "name": "multiply(42, number)",
                        "type": "UInt64"
                },
                {
                        "name": "range(5)",
                        "type": "Array(UInt8)"
                }
        ],

        "data":
        [
                ["hello", "0", "[0,1,2,3,4]"],
                ["hello", "42", "[0,1,2,3,4]"],
                ["hello", "84", "[0,1,2,3,4]"]
        ],

        "rows": 3,

        "rows_before_limit_at_least": 3
}

 

JSONEachRow 

JSONStringsEachRow 

JSONCompactEachRow 

JSONCompactStringsEachRow 

　　使用這些格式時，ClickHouse會將行輸出為用換行符分隔的JSON值，這些輸出數據作為一個整體時，由於沒有分隔符(,)因而不是有效的JSON文檔。

{"some_int":42,"some_str":"hello","some_tuple":[1,"a"]} // JSONEachRow
[42,"hello",[1,"a"]] // JSONCompactEachRow
["42","hello","(2,'a')"] // JSONCompactStringsEachRow

　　在插入數據時，應該為每一行提供一個單獨的JSON值。

JSONEachRowWithProgress 

JSONStringsEachRowWithProgress 

　　與JSONEachRow/JSONStringsEachRow不同的是，ClickHouse還將生成作為JSON值的進度信息。

{"row":{"'hello'":"hello","multiply(42, number)":"0","range(5)":[0,1,2,3,4]}}
{"row":{"'hello'":"hello","multiply(42, number)":"42","range(5)":[0,1,2,3,4]}}
{"row":{"'hello'":"hello","multiply(42, number)":"84","range(5)":[0,1,2,3,4]}}
{"progress":{"read_rows":"3","read_bytes":"24","written_rows":"0","written_bytes":"0","total_rows_to_read":"3"}}

 

JSONCompactEachRowWithNamesAndTypes 

JSONCompactStringsEachRowWithNamesAndTypes 

　　與JSONCompactEachRow/JSONCompactStringsEachRow不同的是，列名和類型被寫入前兩行。

["'hello'", "multiply(42, number)", "range(5)"]
["String", "UInt64", "Array(UInt8)"]
["hello", "0", [0,1,2,3,4]]
["hello", "42", [0,1,2,3,4]]
["hello", "84", [0,1,2,3,4]]

Inserting Data 

INSERT INTO UserActivity FORMAT JSONEachRow {"PageViews":5, "UserID":"4324182021466249494", "Duration":146,"Sign":-1} {"UserID":"4324182021466249494","PageViews":6,"Duration":185,"Sign":1}

 

　　ClickHouse允許:

• 以任意順序排列列名，后跟對應的值。
• 省略一些值。

　　ClickHouse忽略元素之間的空格和對象后面的逗號。您可以在一行中傳遞所有對象，不需要用換行符把它們分開。

省略值處理

　　ClickHouse將省略的值替換為對應的數據類型默認值。

　　如果指定了DEFAULT expr，則ClickHouse根據屬性使用不同的替換規則，詳看input_format_defaults_for_omitted_fields設置。

參考下面的例子：

CREATE TABLE IF NOT EXISTS example_table
(
    x UInt32,
    a DEFAULT x * 2
) ENGINE = Memory;

• 如果input_format_defaults_for_omitted_fields = 0, 那么x和a的默認值等於0(作為UInt32數據類型的默認值)。
• 如果input_format_defaults_for_omitted_fields = 1, 那么x的默認值為0，但a的默認值為x * 2。

　　注意：

　　當使用input_format_defaults_for_omitted_fields = 1插入數據時，與使用input_format_defaults_for_omitted_fields = 0相比，ClickHouse消耗更多的計算資源。

Selecting Data 

　　以UserActivity表為例:

┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐
│ 4324182021466249494 │         5 │      146 │   -1 │
│ 4324182021466249494 │         6 │      185 │    1 │
└─────────────────────┴───────────┴──────────┴──────┘
--當查詢SELECT * FROM UserActivity FORMAT JSONEachRow返回:


{"UserID":"4324182021466249494","PageViews":5,"Duration":146,"Sign":-1}
{"UserID":"4324182021466249494","PageViews":6,"Duration":185,"Sign":1}

　　與JSON格式不同，沒有替換無效的UTF-8序列。值以與JSON相同的方式轉義。

　　提示：

　　字符串中可以輸出任意一組字節。如果您確信表中的數據可以被格式化為JSON而不會丟失任何信息，那么就使用JSONEachRow格式。

Nested Structures 

　　如果您有一個包含Nested數據類型列的表，您可以插入具有相同結構的JSON數據。使用input_format_import_nested_json設置啟用該特性。

例如，請參考下表:

CREATE TABLE json_each_row_nested (n Nested (s String, i Int32) ) ENGINE = Memory
--正如您在Nested數據類型描述中看到的，ClickHouse將嵌套結構的每個部分作為一個單獨的列(n.s和n.i)。您可以通過以下方式插入數據:


INSERT INTO json_each_row_nested FORMAT JSONEachRow {"n.s": ["abc", "def"], "n.i": [1, 23]}

　　將數據作為分層JSON對象集插入，需要設置input_format_import_nested_json=1。

{
    "n": {
        "s": ["abc", "def"],
        "i": [1, 23]
    }
}

　　如果沒有此設置，ClickHouse將引發異常。

SELECT name, value FROM system.settings WHERE name = 'input_format_import_nested_json'

┌─name────────────────────────────┬─value─┐
│ input_format_import_nested_json │ 0     │
└─────────────────────────────────┴───────┘

INSERT INTO json_each_row_nested FORMAT JSONEachRow {"n": {"s": ["abc", "def"], "i": [1, 23]}}
Code: 117. DB::Exception: Unknown field found while parsing JSONEachRow format: n: (at row 1)

SET input_format_import_nested_json=1
INSERT INTO json_each_row_nested FORMAT JSONEachRow {"n": {"s": ["abc", "def"], "i": [1, 23]}}
SELECT * FROM json_each_row_nested

┌─n.s───────────┬─n.i────┐
│ ['abc','def'] │ [1,23] │
└───────────────┴────────┘

 

Native 

　　最高性能的格式。通過二進制格式的塊進行寫入和讀取。對於每個塊，該中的行數，列數，列名稱和類型以及列的部分將被相繼記錄。換句話說，這種格式是columnar的 - 它不會將列轉換為行。這種格式用於服務器間交互、命令行客戶端和C++客戶端與服務器交互。您可以使用此格式快速生成只能由ClickHouse DBMS讀取的格式。但自己處理這種格式是沒有意義的。

Null 

　　沒有輸出。但是，查詢已處理完畢，並且在使用命令行客戶端時，數據將傳輸到客戶端。這僅用於測試，包括性能測試。顯然，這種格式只適用於輸出，不適用於解析。

Pretty 

　　將數據以表格形式輸出，也可以使用ANSI轉義字符在終端中設置顏色。它會繪制一個完整的表格，每行數據在終端中占用兩行。每個結果塊作為一個單獨的表輸出。這是必要的，以便在輸出塊時不緩沖結果(為了預先計算所有值的可見寬度，緩沖是必要的)。NULL輸出為ᴺᵁᴸᴸ。

示例

SELECT * FROM system.numbers limit 2 format Pretty;

┏━━━━━━━━┓
┃ number ┃
┡━━━━━━━━┩
│      0 │
├────────┤
│      1 │
└────────┘
Pretty的所有格式不進行字符轉義。示例顯示了PrettyCompact格式:


SELECT 'String with \'quotes\' and \t character' AS Escaping_test

┌─Escaping_test────────────────────────┐
│ String with 'quotes' and      character │
└──────────────────────────────────────┘

 

　　為避免將太多數據傳輸到終端，只打印前10,000行。 如果行數大於或等於10,000，則會顯示消息Showed first 10 000。該格式僅適用於輸出查詢結果，但不適用於解析輸入(將數據插入到表中)。

　　Pretty格式支持輸出合計值(當使用WITH TOTALS時)和極值(當extremes設置為1時)。在這些情況下，合計值和極值將輸出在主要數據之后，在單獨的表中。示例(顯示為PrettyCompact格式):

SELECT EventDate, count() AS c FROM test.hits GROUP BY EventDate WITH TOTALS ORDER BY EventDate FORMAT PrettyCompact

┌──EventDate─┬───────c─┐
│ 2014-03-17 │ 1406958 │
│ 2014-03-18 │ 1383658 │
│ 2014-03-19 │ 1405797 │
│ 2014-03-20 │ 1353623 │
│ 2014-03-21 │ 1245779 │
│ 2014-03-22 │ 1031592 │
│ 2014-03-23 │ 1046491 │
└────────────┴─────────┘

Totals:
┌──EventDate─┬───────c─┐
│ 1970-01-01 │ 8873898 │
└────────────┴─────────┘

Extremes:
┌──EventDate─┬───────c─┐
│ 2014-03-17 │ 1031592 │
│ 2014-03-23 │ 1406958 │
└────────────┴─────────┘

PrettyCompact 

　　與Pretty格式不一樣的是PrettyCompact去掉了行之間的表格分割線，這樣使得結果更加緊湊。這種格式會在交互命令行客戶端下默認使用。

select * from system.numbers limit 2 format PrettyCompact;

┌─number─┐
│      0 │
│      1 │
└────────┘

PrettyCompactMonoBlock 

　　與PrettyCompact格式不一樣的是，它支持10,000行數據緩沖，然后輸出在一個表格中，而不分塊。

PrettyNoEscapes 

　　與Pretty格式不一樣的是，它不使用ANSI字符轉義，這在瀏覽器顯示數據以及在使用watch命令行工具是有必要的。

　　示例：

watch -n1 "clickhouse-client --query='SELECT event, value FROM system.events FORMAT PrettyCompactNoEscapes'"

　　您可以使用HTTP接口來獲取數據，顯示在瀏覽器中。

PrettyCompactNoEscapes 

PrettySpaceNoEscapes 

　　用法類似上述。

PrettySpace 

　　與PrettyCompact格式不一樣的是，它使用空格來代替網格來顯示數據。

Copy
select * from system.numbers limit 2 format PrettySpace;
Copy
number

     0
     1

RowBinary 

　　以二進制格式逐行格式化和解析數據。行和值連續列出，沒有分隔符。這種格式比 Native 格式效率低，因為它是基於行的。

　　整數使用固定長度的小端表示法。 例如，UInt64 使用8個字節。
　　DateTime 被表示為 UInt32 類型的Unix 時間戳值。
　　Date 被表示為 UInt16 對象，它的值為自1970-01-01以來經過的天數。
　　字符串表示為 varint 長度(無符號 LEB128)，后跟字符串的字節數。
　　FixedString 被簡單地表示為字節序列。

　　數組表示為 varint 長度(無符號 LEB128)，后跟有序的數組元素。

　　對於 NULL 的支持， 一個為 1 或 0 的字節會加在每個 可為空 值前面。如果為 1, 那么該值就是 NULL。 如果為 0，則不為 NULL。

RowBinaryWithNamesAndTypes 

　　類似於 RowBinary，但添加了頭部信息:

• LEB128-編碼列數(N)
• N Strings指定列名
• N Strings指定列類型

Values 

　　在括號中打印每一行。行由逗號分隔。最后一行之后沒有逗號。括號內的值也用逗號分隔。數字以十進制格式輸出，不含引號。 數組以方括號輸出。字符串、日期、日期時間用引號包圍輸出。轉義字符的解析規則與 TabSeparated 格式類似。 在格式化過程中，不插入額外的空格，但在解析過程中，空格是被允許並跳過的(除了數組值之外的空格，這是不允許的)。NULL 為 NULL。

　　以 Values 格式傳遞數據時需要轉義的最小字符集是：單引號和反斜線。

　　這是 INSERT INTO t VALUES ... 中可以使用的格式，但您也可以將其用於查詢結果。

　　可參考查看：input_format_values_interpret_expressions和input_format_values_deduce_templates_of_expressions的配置。

Vertical 

　　根據指定的列名，打印出每一行的值。這種格式適用於具有大量的列時，顯示幾個列。NULL 輸出為 ᴺᵁᴸᴸ。

　　示例:

SELECT * FROM t_null FORMAT Vertical

Row 1:
──────
x: 1
y: ᴺᵁᴸᴸ

　　該格式僅適用於輸出查詢結果，但不適用於解析輸入(將數據插入到表中)。

XML 

　　該格式僅適用於輸出查詢結果，但不適用於解析輸入，示例：

<?xml version='1.0' encoding='UTF-8' ?>
<result>
        <meta>
                <columns>
                        <column>
                                <name>SearchPhrase</name>
                                <type>String</type>
                        </column>
                        <column>
                                <name>count()</name>
                                <type>UInt64</type>
                        </column>
                </columns>
        </meta>
        <data>
                <row>
                        <SearchPhrase></SearchPhrase>
                        <field>8267016</field>
                </row>
                <row>
                        <SearchPhrase>bathroom interior design</SearchPhrase>
                        <field>2166</field>
                </row>
                <row>
                        <SearchPhrase>yandex</SearchPhrase>
                        <field>1655</field>
                </row>
                <row>
                        <SearchPhrase>2014 spring fashion</SearchPhrase>
                        <field>1549</field>
                </row>
                <row>
                        <SearchPhrase>freeform photos</SearchPhrase>
                        <field>1480</field>
                </row>
                <row>
                        <SearchPhrase>angelina jolie</SearchPhrase>
                        <field>1245</field>
                </row>
                <row>
                        <SearchPhrase>omsk</SearchPhrase>
                        <field>1112</field>
                </row>
                <row>
                        <SearchPhrase>photos of dog breeds</SearchPhrase>
                        <field>1091</field>
                </row>
                <row>
                        <SearchPhrase>curtain designs</SearchPhrase>
                        <field>1064</field>
                </row>
                <row>
                        <SearchPhrase>baku</SearchPhrase>
                        <field>1000</field>
                </row>
        </data>
        <rows>10</rows>
        <rows_before_limit_at_least>141137</rows_before_limit_at_least>
</result>

　　如果列名稱沒有可接受的格式，則僅使用 field 作為元素名稱。 通常，XML 結構遵循 JSON 結構。就像JSON一樣，將無效的 UTF-8 字符都替換成字符�，以便輸出文本將包含有效的 UTF-8 字符序列。

　　在字符串值中，字符 < 和 ＆ 被轉義為 < 和 &。數組輸出類似於 <array> <elem> Hello </ elem> <elem> World </ elem> ... </ array>，元組輸出類似於 <tuple> <elem> Hello </ elem> <elem> World </ ELEM> ... </tuple> 。

 

CapnProto 

　　Cap’n Proto 是一種二進制消息格式，類似Protobuf和Thriftis，但與 JSON 或 MessagePack 格式不一樣。Cap’n Proto 消息格式是嚴格類型的，而不是自我描述，這意味着它們需要架構描述。架構描述可以實時地應用，並針對每個查詢進行緩存。

SELECT SearchPhrase, count() AS c FROM test.hits
       GROUP BY SearchPhrase FORMAT CapnProto SETTINGS schema = 'schema:Message'
--其中 schema.capnp 描述如下：6y2


struct Message {
  SearchPhrase @0 :Text;
  c @1 :Uint64;
}

　　格式文件存儲的目錄可以在服務配置中的 format_schema_path 指定。Cap’n Proto 反序列化是很高效的，通常不會增加系統的負載。

Protobuf 

　　Protobuf-是一個 Protocol Buffers 格式。此格式需要外部格式描述文件(proto文件)。 該描述文件會進行緩存，以備后續查詢。ClickHouse支持 proto2 和 proto3 語法的proto文件，支持重復/可選/必填字段。

使用示例:

SELECT * FROM test.table FORMAT Protobuf SETTINGS format_schema = 'schemafile:MessageType'

cat protobuf_messages.bin | clickhouse-client --query "INSERT INTO test.table FORMAT Protobuf SETTINGS format_schema='schemafile:MessageType'"
--proto文件 schemafile.proto 看起來像這樣:


syntax = "proto3";

message MessageType {
  string name = 1;
  string surname = 2;
  uint32 birthDate = 3;
  repeated string phoneNumbers = 4;
};
--Clickhouse通過字段名稱來對應列名稱。字段名稱不區分大小寫，_與.視為相同符號。如果Proto文件指定的字段類型與列類型不相符，會進行轉換。

--支持Protobuf嵌套消息。 例如，對於下面Proto文件中的z字段：


message MessageType {
  message XType {
    message YType {
      int32 z;
    };
    repeated YType y;
  };
  XType x;
};
--ClickHouse會試圖找到一個名為 x.y.z (或 x_y_z 或 X.y_Z 等)的列。
--嵌套消息適用於輸入或輸出一個 嵌套數據結構.

--在protobuf模式中定義的默認值，如下：


syntax = "proto2";

message MessageType {
  optional int32 result_per_page = 3 [default = 10];
}
--該默認值會被忽略，Clickhouse會使用 表默認值作為默認值。

　　ClickHouse在輸入和輸出protobuf消息采用length-delimited 格式。這意味着每個消息之前，應該寫它的長度作為一個 varint.

Avro 

　　Apache Avro 是在Apache Hadoop項目中開發的面向行的數據序列化框架。ClickHouse Avro格式支持讀取和寫入 Avro數據文件.

數據類型匹配{#sql_reference/data_types-matching} 

　　下表顯示了支持的數據類型以及它們如何匹配ClickHouse 數據類型 在 INSERT 和 SELECT 查詢。

Avro數據類型 INSERT	ClickHouse數據類型	Avro數據類型 SELECT
boolean, int, long, float, double	Int(8/16/32), UInt(8/16/32)	int
boolean, int, long, float, double	Int64, UInt64	long
boolean, int, long, float, double	Float32	float
boolean, int, long, float, double	Float64	double
bytes, string, fixed, enum	String	bytes
bytes, string, fixed	FixedString(N)	fixed(N)
enum	Enum(8|16)	enum
array(T)	Array(T)	array(T)
union(null, T), union(T, null)	Nullable(T)	union(null, T)
null	Nullable(Nothing)	null
int (date) *	Date	int (date) *
long (timestamp-millis) *	DateTime64(3)	long (timestamp-millis) *
long (timestamp-micros) *	DateTime64(6)	long (timestamp-micros) *

　　* Avro邏輯類型

　　不支持的Avro數據類型: record (非根架構), map

　　不支持的Avro邏輯數據類型: time-millis, time-micros, duration

插入數據 

　　將Avro文件中的數據插入ClickHouse表:

$ cat file.avro | clickhouse-client --query="INSERT INTO {some_table} FORMAT Avro"

　　輸入Avro文件的根架構必須是 record 類型。Clickhouse通過字段名稱來對應架構的列名稱。字段名稱區分大小寫。未使用的字段會被跳過。ClickHouse表列的數據類型可能與插入的Avro數據的相應字段不同。 插入數據時，ClickHouse根據上表解釋數據類型，然后通過 Cast 將數據轉換為相應的列類型。

選擇數據 

　　從ClickHouse表中選擇數據到Avro文件:

$ clickhouse-client --query="SELECT * FROM {some_table} FORMAT Avro" > file.avro

　　列名必須:

• 以 [A-Za-z_] 開始
• 隨后只包含 [A-Za-z0-9_]

　　輸出Avro文件壓縮和同步間隔可以經由 output_format_avro_codec 和 output_format_avro_sync_interval 設置。

AvroConfluent 

　　AvroConfluent支持解碼單個對象的Avro消息，這常用於 Kafka 和 Confluent Schema Registry。每個Avro消息都嵌入了一個架構id，該架構id可以在架構注冊表的幫助下解析為實際架構。模式解析后會進行緩存。架構注冊表URL配置為 format_avro_schema_registry_url

數據類型匹配{#sql_reference/data_types-matching-1} 

　　和 Avro相同。

用途 

　　要快速驗證架構解析，您可以使用 kafkacat 與 clickhouse-local:

$ kafkacat -b kafka-broker  -C -t topic1 -o beginning -f '%s' -c 3 | clickhouse-local   --input-format AvroConfluent --format_avro_schema_registry_url 'http://schema-registry' -S "field1 Int64, field2 String"  -q 'select *  from table'
1 a
2 b
3 c

 

　　使用 AvroConfluent 與 Kafka:

CREATE TABLE topic1_stream
(
    field1 String,
    field2 String
)
ENGINE = Kafka()
SETTINGS
kafka_broker_list = 'kafka-broker',
kafka_topic_list = 'topic1',
kafka_group_name = 'group1',
kafka_format = 'AvroConfluent';

SET format_avro_schema_registry_url = 'http://schema-registry';

SELECT * FROM topic1_stream;

　　警告:

　　設置 format_avro_schema_registry_url 需要寫入配置文件users.xml以在Clickhouse重啟后，該設置仍為您的設定值。您也可以在使用Kafka引擎的時候指定該設置。

Parquet 

　　Apache Parquet 是Hadoop生態系統中普遍使用的列式存儲格式。 ClickHouse支持此格式的讀寫操作。

數據類型匹配{#sql_reference/data_types-matching-2} 

　　下表顯示了Clickhouse支持的數據類型以及它們在 INSERT 和 SELECT 查詢如何對應Clickhouse的 data types 。

Parquet數據類型 (INSERT)	ClickHouse數據類型	Parquet數據類型 (SELECT)
UINT8, BOOL	UInt8	UINT8
INT8	Int8	INT8
UINT16	UInt16	UINT16
INT16	Int16	INT16
UINT32	UInt32	UINT32
INT32	Int32	INT32
UINT64	UInt64	UINT64
INT64	Int64	INT64
FLOAT, HALF_FLOAT	Float32	FLOAT
DOUBLE	Float64	DOUBLE
DATE32	Date	UINT16
DATE64, TIMESTAMP	DateTime	UINT32
STRING, BINARY	String	STRING
—	FixedString	STRING
DECIMAL	Decimal	DECIMAL

　　ClickHouse支持對 Decimal 類型設置精度。 INSERT 查詢將 Parquet DECIMAL 類型視為ClickHouse Decimal128 類型。不支持的Parquet數據類型: DATE32, TIME32, FIXED_SIZE_BINARY, JSON, UUID, ENUM.ClickHouse表列的數據類型可能與插入的Parquet數據的相應字段不同。 插入數據時，ClickHouse根據上表解釋數據類型，然后 Cast 為ClickHouse表列設置的數據類型的數據。

插入和選擇數據 

--您可以通過以下命令將Parquet數據從文件插入到ClickHouse表中:


$ cat {filename} | clickhouse-client --query="INSERT INTO {some_table} FORMAT Parquet"
--您可以從ClickHouse表中選擇數據，並通過以下命令將它們保存到Parquet格式的文件中:


$ clickhouse-client --query="SELECT * FROM {some_table} FORMAT Parquet" > {some_file.pq}

　　要與Hadoop交換數據，您可以使用 HDFS table engine.

Arrow 

　　Apache Arrow是一種用於內存數據庫的格式，共有兩種模式，文件與流模式。Clickhouse支持對這兩種格式進行讀寫。Arrow對應的是文件模式，這種格式適用於內存的隨機訪問。

ArrowStream 

　　ArrowStream對應的是Arrow的流模式，這種格式適用於內存的流式處理。

ORC 

　　Apache ORC 是Hadoop生態系統中普遍存在的列式存儲格式。

數據類型匹配{#sql_reference/data_types-matching-3} 

　　下表顯示了支持的數據類型以及它們如何在SELECT與INSERT查詢中匹配ClickHouse的 數據類型。

ORC 數據類型 (INSERT)	ClickHouse 數據類型	ORC 數據類型 (SELECT)
UINT8, BOOL	UInt8	UINT8
INT8	Int8	INT8
UINT16	UInt16	UINT16
INT16	Int16	INT16
UINT32	UInt32	UINT32
INT32	Int32	INT32
UINT64	UInt64	UINT64
INT64	Int64	INT64
FLOAT, HALF_FLOAT	Float32	FLOAT
DOUBLE	Float64	DOUBLE
DATE32	Date	DATE32
DATE64, TIMESTAMP	DateTime	TIMESTAMP
STRING, BINARY	String	BINARY
DECIMAL	Decimal	DECIMAL
-	Array	LIST

　　ClickHouse支持的可配置精度的 Decimal 類型。 INSERT 查詢將ORC格式的 DECIMAL 類型視為ClickHouse的 Decimal128 類型。不支持的ORC數據類型: TIME32, FIXED_SIZE_BINARY, JSON, UUID, ENUM.ClickHouse表列的數據類型不必匹配相應的ORC數據字段。 插入數據時，ClickHouse根據上表解釋數據類型，然后 Cast 將數據轉換為ClickHouse表列的數據類型集。

插入數據 

　　您可以通過以下命令將文件中的ORC數據插入到ClickHouse表中:

$ cat filename.orc | clickhouse-client --query="INSERT INTO some_table FORMAT ORC"

選擇數據 

　　您可以通過以下命令將ClickHouse表中某些數據導出到ORC文件:

$ clickhouse-client --query="SELECT * FROM {some_table} FORMAT ORC" > {filename.orc}

　　要與Hadoop交換數據，您可以使用 HDFS表引擎.

LineAsString 

　　這種格式下，每行輸入數據都會當做一個字符串。這種格式僅適用於僅有一列String類型的列的表。其余列必須設置為DEFAULT、MATERIALIZED或者被忽略。

示例： 

　　查詢如下：

DROP TABLE IF EXISTS line_as_string;
CREATE TABLE line_as_string (field String) ENGINE = Memory;
INSERT INTO line_as_string FORMAT LineAsString "I love apple", "I love banana", "I love orange";
SELECT * FROM line_as_string;
結果如下：


┌─field─────────────────────────────────────────────┐
│ "I love apple", "I love banana", "I love orange"; │
└───────────────────────────────────────────────────┘

Regexp 

　　每一列輸入數據根據正則表達式解析。使用Regexp格式時，可以使用如下設置：

• format_regexp，String類型。包含re2格式的正則表達式。
• format_regexp_escaping_rule，String類型。支持如下轉義規則：
• CSV(規則相同於CSV)
• JSON(相同於JSONEachRow)
• Escaped(相同於TSV)
• Quoted(相同於Values)
• Raw(將整個子匹配項進行提取，不轉義)
• format_regexp_skip_unmatched，UInt8類型。當format_regexp表達式沒有匹配到結果時是否拋出異常。可為0或1。

用法 

　　format_regexp設置會應用於每一行輸入數據。正則表達式的子匹配項數必須等於輸入數據期望得到的列數。每一行輸入數據通過換行符\n或者\r\n分隔。匹配到的子匹配項會根據每一列的數據格式進行解析，轉義規則根據format_regexp_escaping_rule進行。當正則表達式對某行沒有匹配到結果，format_regexp_skip_unmatched設為1時，該行會被跳過。format_regexp_skip_unmatched設為0時，會拋出異常。

示例 

　　設有如下data.tsv:

id: 1 array: [1,2,3] string: str1 date: 2020-01-01
id: 2 array: [1,2,3] string: str2 date: 2020-01-02
id: 3 array: [1,2,3] string: str3 date: 2020-01-03

與表:

CREATE TABLE imp_regex_table (id UInt32, array Array(UInt32), string String, date Date) ENGINE = Memory;

導入命令：

$ cat data.tsv | clickhouse-client  --query "INSERT INTO imp_regex_table FORMAT Regexp SETTINGS format_regexp='id: (.+?) array: (.+?) string: (.+?) date: (.+?)', format_regexp_escaping_rule='Escaped', format_regexp_skip_unmatched=0;"

--查詢：

SELECT * FROM imp_regex_table;
--結果：


┌─id─┬─array───┬─string─┬───────date─┐
│  1 │ [1,2,3] │ str1   │ 2020-01-01 │
│  2 │ [1,2,3] │ str2   │ 2020-01-02 │
│  3 │ [1,2,3] │ str3   │ 2020-01-03 │
└────┴─────────┴────────┴────────────┘

RawBLOB 

　　這種格式下，所有輸入數據視為一個值。該格式僅適用於僅有一String類型的列的表。輸出時，使用二進制格式輸出。當輸出結果不唯一時，輸出是有歧義的，並且不能通過該輸出還原原數據。
下面是RawBLOB與TabSeparatedRaw的對比：

　　RawBloB:

• 二進制格式輸出，無轉義。
• 值之間沒有分隔符。
• 每行最后的值后面沒有換行符。

　　TabSeparatedRaw:

• 數據無轉義輸出。
• 每行的值通過制表符分隔。
• 每行最后的值得后面有換行符。

　　下面是RawBLOB與RowBinary的對比：

　　RawBloB:

• 字符串前面沒有表示長度的標志

　　RowBinary:

• 字符串前面有變長標志(LEB128格式表示)，用於表示字符串長度，后接字符串內容。

　　當傳入空數據，Clickhouse會拋出異常：

Code: 108. DB::Exception: No data to insert

示例 

$ clickhouse-client --query "CREATE TABLE {some_table} (a String) ENGINE = Memory;"
$ cat {filename} | clickhouse-client --query="INSERT INTO {some_table} FORMAT RawBLOB"
$ clickhouse-client --query "SELECT * FROM {some_table} FORMAT RawBLOB" | md5sum
--結果：

f9725a22f9191e064120d718e26862a9  -

 

格式架構 

　　包含格式架構的文件名由設置 format_schema指定.當使用CapnProto 或 Protobuf其中一種格式時，需要設置該項.
　　格式架構為架構文件名和此文件中消息類型的組合，用冒號分隔,例如 schemafile.proto:MessageType.
　　如果文件具有格式的標准擴展名(例如, Protobuf格式的架構文件標准擴展名為.proto),它可以被省略，在這種情況下，格式模式如下所示 schemafile:MessageType.

　　如果您通過Client 在 交互模式下輸入或輸出數據，格式架構中指定的文件名可以使用絕對路徑或客戶端當前目錄的相對路徑。
　　如果在批處理模式下使用客戶端，則由於安全原因，架構的路徑必須使用相對路徑。

　　如果您通過 HTTP接口輸入或輸出數據，格式架構中指定的文件名應該位於服務器設置的format_schema_path指定的目錄中。

跳過錯誤 

　　一些格式，如 CSV, TabSeparated, TSKV, JSONEachRow, Template, CustomSeparated 和 Protobuf 如果發生解析錯誤，可以跳過引發錯誤的行，並從下一行開始繼續解析。 可設置input_format_allow_errors_num 和input_format_allow_errors_ratio 。　　　　　　

　　限制:
　　- 在解析錯誤的情況下 JSONEachRow 跳過該行的所有數據，直到遇到新行(或EOF)，所以行必須由換行符分隔以正確統計錯誤行的數量。
　　- Template 和 CustomSeparated 在最后一列之后和行之間使用分隔符來查找下一行的開頭，所以跳過錯誤只有在行分隔符和列分隔符其中至少有一個不為空時才有效。

時區采用客戶端或服務器端時區(取決於誰對數據進行格式化)。對於帶有時間的日期，沒有是哦用夏時制時間。因此，如果導出的數據采用了夏時制，則實際入庫的時間不一定與預期的時間對應，解析將根據解析動作發起方選擇時間。

　　直接執行sql腳本導入：可指定用戶名密碼，此處使用默認賬戶 注意  multiquery 

clickhouse client -d isv_data_prod --multiquery < merdata.sql