some codes

extern crate arrow;
extern crate tokio;

use std::convert::TryFrom;
use std::sync::Arc;
// use arrow::array::{Float64Array, Int64Array, Date32Array, Date64Array, Time64MicrosecondArray, Float32Builder, Float16Array};
use arrow::ipc::TimeUnit;
use datafusion::arrow::array::{Int32Array, 
    BooleanArray,
    BooleanBuilder,
    ArrayRef,
    ArrayData
};
use datafusion::arrow::datatypes::{
    DataType, 
    Field, 
    Schema};
use datafusion::arrow::record_batch::RecordBatch;
use datafusion::datasource::MemTable;
use datafusion::error::Result;
use datafusion::from_slice::FromSlice;
use datafusion::prelude::*;

use datafusion::arrow::{array::{
    Int8Array, StringArray,
    PrimitiveBuilder, StringBuilder, StringDictionaryBuilder,Float32Builder,
    Float64Builder,
    Int64Builder,
    Date32Builder,
    Date64Builder,
    StructArray,
    Array
    // ArrayData
  },
  datatypes::Int8Type,
};


#[tokio::main]
async fn main(){
    // 字符串
    let mut sbuilder = StringBuilder::new(100);
    sbuilder.append_value("a").unwrap();
    sbuilder.append_null().unwrap();
    sbuilder.append_value("许多编程语言里，我们都非常乐于去研究在这个语言中所使用的异步网络编程的框架，比如说Python的 Gevent、asyncio，Nginx 和 OpenResty，Go 等，今年年初我开始接触 Rust，并被其无 GC、内存安全、极小的运行时等特性所吸引，经过一段时间的学习，开始寻找构建实际项目的解决方案，很快 mio、tokio 等框架进入了我的视野，于是开始从更加底层的 mio 出发实验。
    https://github.com/Hevienz/mio_test/blob/master/src/main.rs
    可以看到 mio 是一个非常底层的异步编程的框架，这意味着如果我们要在实际的项目开发中使用它时，就不得不从 event loop 开始编写我们的软件，这并不是我们所期望的，于是我们需要一个更高层次抽象的框架，这便是本文要为大家讲述的 tokio。
    tokio
    tokio 是 Rust 中的异步编程框架，它将复杂的异步编程抽象为 Futures、Tasks 和 Executor，并提供了 Timers 等基础设施，下文中我们将一一展开。
    运行时模型
    tokio 是一个基于轮训的模型。比如我们要在 tokio 上调度我们的 task，我们需要为其实现 Future trait。比如下面的例子中，我们想要得到一个 widget，但它有可能还没有准备好，这时候我们调用 poll 的结果就是 Ok(Async::NotReady)，Executor 会负责重复的调用 poll，直到 widget 准备好，返回Ok(Async::Ready(()))。
    pub struct MyTask;").unwrap();
    sbuilder.append_value("add").unwrap();
    sbuilder.append_value("aaaaaa").unwrap();
    let astr = sbuilder.finish();

    // i32
    let mut builder = Int32Array::builder(5);
    builder.append_value(5).unwrap();
    builder.append_null().unwrap();
    builder.append_slice(&[1,2,3]).unwrap();
    let ai32 = builder.finish();

    // bool
     let mut c = BooleanBuilder::new(5);
     c.append_value(true).unwrap();
     c.append_value(true).unwrap();
     c.append_null().unwrap();
     c.append_value(false).unwrap();
     c.append_value(true).unwrap();
     let abool = c.finish();

    // f64
    // let mut f64a = Float64Array::builder(5);
    let mut f64a = Float64Builder::new(5);
    f64a.append_value(5.9).unwrap();
    f64a.append_value(5.1).unwrap();
    f64a.append_null().unwrap();
    f64a.append_value(5.2).unwrap();
    f64a.append_value(5.6).unwrap();
    let af64 = f64a.finish();

    // i64
    let mut i64a = Int64Builder::new(5);
    i64a.append_value(4).unwrap();
    i64a.append_value(4).unwrap();
    i64a.append_null().unwrap();
    i64a.append_value(4).unwrap();
    i64a.append_value(4).unwrap();
    let ai64 = i64a.finish();

    // date32
    let mut d32a = Date32Builder::new(5);
    d32a.append_value(45001).unwrap();
    d32a.append_value(45001).unwrap();
    d32a.append_null().unwrap();
    d32a.append_value(45001).unwrap();
    d32a.append_value(45001).unwrap();
    let ad32 = d32a.finish();

    // date64
    let mut d64a = Date64Builder::new(5);
    d64a.append_value(46502).unwrap();
    d64a.append_value(46502).unwrap();
    d64a.append_null().unwrap();
    d64a.append_value(46502).unwrap();
    d64a.append_value(46502).unwrap();
    let ad64 = d64a.finish();
    
    let mut f32l = Float32Builder::new(100);
    f32l.append_value(1.1).unwrap();
    f32l.append_null();
    f32l.append_value(1.2).unwrap();
    f32l.append_value(1.3).unwrap();
    f32l.append_value(1.4).unwrap();
    let af32 = f32l.finish();

    // Utf8
    // Int32
    // Boolean
    // Float64
    // Int64
    // Date32
    // Date64
    // Float32

    let schema = Arc::new(Schema::new(vec![
        Field::new("astr", DataType::Utf8, false),
        Field::new("ai32", DataType::Int32, false),
        Field::new("abool", DataType::Boolean, false),
        Field::new("af64", DataType::Float64, false),
        Field::new("ai64", DataType::Int64, false),
        Field::new("ad32", DataType::Date32, false),
        Field::new("ad64", DataType::Date64, false),
        Field::new("af32", DataType::Float32, false),
    ]));
    let batch = RecordBatch::try_new(
        schema.clone(),
        vec![
            Arc::new(astr),
            Arc::new(ai32),
            Arc::new(abool),
            Arc::new(af64),
            Arc::new(ai64),
            Arc::new(ad32),
            Arc::new(ad64),
            Arc::new(af32),
        ],
    ).unwrap();

    for each in batch.columns(){
        println!("{:?}", each.data_type());
    }

    // let xx = batch.column(0);
    // let yy = xx.clone().;
    // let zz = yy.as_any();
    // let zzz:Option<&String> = zz.downcast_ref();
    // // let zz = yy.offset();
    // // let zzz = zz.0;
    // println!("{:?}",zzz);

    // for each in batch.columns().into_iter(){
    //     println!("{:?}", each);
    //     println!("---------------------");
    // }
        
    // println!("====================");
    // let ctx = SessionContext::new();
    // let provider = MemTable::try_new(schema, vec![vec![batch]]).unwrap();
    // ctx.register_table("t", Arc::new(provider)).unwrap();

    // let df:Arc<DataFrame> = ctx.table("t").unwrap();
    // df.show().await().unwrap();
    // ====================================================================================================================


    // let struct_array = StructArray::from(vec![
    //     (
    //         Field::new("b", DataType::Boolean, false),
    //         Arc::new(BooleanArray::from(vec![false, false, true, true]))
    //             as Arc<dyn Array>,
    //     ),
    //     (
    //         Field::new("c", DataType::Int32, false),
    //         Arc::new(Int32Array::from(vec![42, 28, 19, 31])),
    //     ),
    // ]);
    // let aaa = struct_array.column_by_name("c").unwrap();
    // // let l = &aaa.len();
    // // let ll = l.clone();
    // // let ccc = aaa.slice(1, 1);
    // println!("{:?}", aaa.data().);
    // // for i in 0..ll{
    // //     println!("{:?}", aaa.slice(i, 1));
    // // }



    // ==================================================================================================================
    // let mut sbuilder = StringBuilder::new(100);
    // sbuilder.append_value("a").unwrap();
    // sbuilder.append_null().unwrap();
    // sbuilder.append_value("hello").unwrap();
    // sbuilder.append_value("add").unwrap();
    // sbuilder.append_value("aaaaaa").unwrap();
    // let a = sbuilder.finish();

    // let mut sd = Float32Builder::new(5);
    // sd.append_value(DataType::Decimal(4, 2));


    // let schema = Arc::new(Schema::new(vec![
    //     Field::new("a", DataType::Utf8, false),
    // ]));
    // let batch = RecordBatch::try_new(
    //     schema.clone(),
    //     vec![
    //         Arc::new(a),
    //     ],
    // ).unwrap();
    // let c = batch.column(0);
    // let d = c.data_type();
    // println!("{:?}", d);

    // let e = c.as_any().downcast_ref::<StringArray>();
    // let f: &StringArray = e.unwrap();
    // println!("{:?}", f);
    // let xxxx = f.value(0);
    // print!("{:?}", xxxx); 
    // match d{
    //     DataType::Utf8 => print!("utf8"),
    //     _ => print!("unknow"),
    // }
}