Currently especially when inserting data, there doesn't appear to be a good way to create a decimal number using this library? Perhaps we could use rust_decimal here as a feature?

I'm writing a kafka consumer, it consumes message and insert those message into clickhouse according to message's meta info, like:

{
  "table": "ch_table_1",
  "data": [
    {"col_name": "foo", "type": "uint32", "val": "3"},
    {"col_name": "bar", "type": "string", "val": "hello"}
    //...
  ]
}

How do I construct the Row to insert? Didn't find any docs about this

When performing a select query on a database with big arrays, the channel created to receive the query results get a capacity overflow. This is so because it eventually fails to read correctly the size of the array. It looks like the pointer is not correctly placed when reading arrays. (Fixing the size for a quick test returns the array values with 0's at the beginning, so all the values are shifted). @Protryon

There are read_exact calls at Line#58 and Line#61.

https://github.com/Protryon/klickhouse/blob/ce78975828b85c2955ed8889a8e8f5b889d76a63/klickhouse/src/io.rs#L47-L65

/*
create table trade_event (
    symbol LowCardinality(FixedString(16)),
    exchange_id LowCardinality(String),
    trade_id UInt64,
    ts DateTime64(6),
    received_ts DateTime64(6),
    is_buyer_maker Nullable(Bool),
    price Decimal64(6),
    size Decimal64(6)
) 
engine = MergeTree()
partition by ts
order by (symbol, exchange_id, ts);
*/

#[derive(Row, Debug, Default)]
pub struct TradeEvent {
  symbol: String,
  exchange_id: String,
  trade_id: u64,
  ts: DateTime64<6>,
  received_ts: DateTime64<6>,
  is_buyer_maker: Option<bool>,
  price: FixedPoint64<6>,
  size: FixedPoint64<6>,
}

Reading the row this currently gives the following error:

thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: DeserializeErrorWithColumn("is_buyer_maker", "unexpected type: Int8")',

EDIT: Looks like not just option, its without as well.

Hey, thanks for working on this crate. I've run into an issue where DEFAULT columns are not getting set properly.

To reproduce the issue, you can follow these steps:

1. Create test table

create table test (id UInt32, id_bump DEFAULT id+1) ENGINE = MergeTree() ORDER BY id;

2. Insert values

// main.rs

#[derive(Row, Debug, Default)]
pub struct Test {
    id: u32,
}

// glue code

#[tokio::main]
async fn main() {
    // init client
    
    let row = Test {
        id: 1,
    };
    
    client
        .insert_native_block("INSERT INTO test FORMAT native", vec![row])
        .await
        .unwrap();
 }

On querying the table, I see that the default expression (id+1) set for column id_bump is not being honored. Any idea why this may be?

Observed:

SELECT *
FROM test

┌─id─┬─id_bump─┐
│  1 │       0 │
└────┴─────────┘

Expected:

SELECT *
FROM test

┌─id─┬─id_bump─┐
│  1 │       2 │
└────┴─────────┘

cc: @tekjar

Dude, the error handling on this is terrible. Most errors are not returned, but simply logged. And there is no trace about the path it took to reach that error.

I submit a SQL query that was expected to return 7 million rows, but the client threw an error : " ERROR [tokio-runtime-worker] [/Users/bmmcq/.cargo/registry/src/github.com-1ecc6299db9ec823/klickhouse-0.2.1/src/client.rs:168] clickhouse client failed: unexpected end of file " and exit with the wrong number of rows.

There is the code:

#[tokio::main]
async fn main() {
    pegasus_common::logs::init_log();
    let mut opt = ClientOptions::default();
    opt.default_database = "mydb".to_owned();
    let client = Client::connect("myip:9000", opt)
        .await
        .unwrap();
    let query = "select * from mytable where my_id in (8,10,11,13,15,17,19,20,22,24,26,28,30)";
    let start = Instant::now();
    let mut all_rows = client
        .query_raw(query)
        .await
        .unwrap();

    let mut count = 0u64;
    while let Some(row) = all_rows.next().await {
        println!("row {}", row.rows);
        count += row.rows;
    }
    println!("total received {} records, used {:?};", count, start.elapsed());
}

Like that

#[derive(Row, Debug, Default)]
pub struct MyUserData {
   #[serde(rename = "Id")]
   id: Uuid,
   #[serde(rename = "UserData")]
   user_data: String,
   #[serde(rename = "CreatedAt")]
   created_at: DateTime,
}

hello,my bro.i'm a beginner on Rust,so maybe something i say sounds childrens,on your eyes..

Problem

https://stackoverflow.com/questions/61179070/rust-chrono-parse-date-string-parseerrornotenough-and-parseerrortooshort I want to conver a standard datatime "2022-04-22 00:00:00" convert to the klickhouse::DateTime. it should be okay,but failed. During finding the bug step by step, I write a test for this.

    #[test]
    fn test_consistency_with_convert_for_str() {
        let test_date = "2022-04-22 00:00:00";

        let dt = chrono::NaiveDateTime::parse_from_str(test_date, "%Y-%m-%d %H:%M:%S").unwrap();

        let chrono_date =
            chrono::DateTime::<Tz>::from_utc(dt, chrono_tz::UTC.offset_from_utc_datetime(&dt));

        let date = DateTime(UTC, dt.timestamp() as u32);

        let new_chrono_date: chrono::DateTime<Tz> = date.into();

        assert_eq!(new_chrono_date, chrono_date);
    }

also,there have two test before in the file src/values/date.rs...i confrim the old impl for From cant not pass this test_case. @Protryon

At the moment we have klickhouse::Row derivable trait and klickhouse::Block raw columnar storage. It would be ideal to have a derivable, easy-to-use klickhouse::Columnar derivable trait akin to klickhouse::Row but with the superior performance of actually being columnar.

No idea when I'll have time/motivation to implement this, but it's been on my mind.