diff --git a/SeasClick.cpp b/SeasClick.cpp
index 281ced9..cfa0a22 100644
--- a/SeasClick.cpp
+++ b/SeasClick.cpp
@@ -45,13 +45,13 @@ map<int, Client*> clientMap;
 
 #ifdef COMPILE_DL_SEASCLICK
 extern "C" {
-ZEND_GET_MODULE(SeasClick)
+    ZEND_GET_MODULE(SeasClick)
 }
 #endif
 
 PHP_FUNCTION(SeasClick_version)
 {
-	SC_RETURN_STRINGL(PHP_SEASCLICK_VERSION, strlen(PHP_SEASCLICK_VERSION));
+    SC_RETURN_STRINGL(PHP_SEASCLICK_VERSION, strlen(PHP_SEASCLICK_VERSION));
 }
 
 static PHP_METHOD(SEASCLICK_RES_NAME, __construct);
@@ -81,9 +81,10 @@ ZEND_ARG_INFO(0, params)
 ZEND_END_ARG_INFO()
 
 /* {{{ SeasClick_functions[] */
-const zend_function_entry SeasClick_functions[] = {
-	PHP_FE(SeasClick_version,	NULL)
-	PHP_FE_END
+const zend_function_entry SeasClick_functions[] =
+{
+    PHP_FE(SeasClick_version,	NULL)
+    PHP_FE_END
 };
 /* }}} */
 
@@ -116,7 +117,7 @@ PHP_MINIT_FUNCTION(SeasClick)
     zend_declare_property_bool(SeasClick_ce, "compression", strlen("compression"), false, ZEND_ACC_PROTECTED TSRMLS_CC);
 
     SeasClick_ce->ce_flags = ZEND_ACC_IMPLICIT_PUBLIC;
-	return SUCCESS;
+    return SUCCESS;
 }
 /* }}} */
 
@@ -124,7 +125,7 @@ PHP_MINIT_FUNCTION(SeasClick)
  */
 PHP_MSHUTDOWN_FUNCTION(SeasClick)
 {
-	return SUCCESS;
+    return SUCCESS;
 }
 /* }}} */
 
@@ -132,7 +133,7 @@ PHP_MSHUTDOWN_FUNCTION(SeasClick)
  */
 PHP_RINIT_FUNCTION(SeasClick)
 {
-	return SUCCESS;
+    return SUCCESS;
 }
 /* }}} */
 
@@ -140,7 +141,7 @@ PHP_RINIT_FUNCTION(SeasClick)
  */
 PHP_RSHUTDOWN_FUNCTION(SeasClick)
 {
-	return SUCCESS;
+    return SUCCESS;
 }
 /* }}} */
 
@@ -148,29 +149,30 @@ PHP_RSHUTDOWN_FUNCTION(SeasClick)
  */
 PHP_MINFO_FUNCTION(SeasClick)
 {
-	php_info_print_table_start();
-	php_info_print_table_header(2, "SeasClick support", "enabled");
+    php_info_print_table_start();
+    php_info_print_table_header(2, "SeasClick support", "enabled");
     php_info_print_table_row(2, "Version", PHP_SEASCLICK_VERSION);
     php_info_print_table_row(2, "Author", "SeasX Group[email: ahhhh.wang@gmail.com]");
-	php_info_print_table_end();
+    php_info_print_table_end();
 
-	DISPLAY_INI_ENTRIES();
+    DISPLAY_INI_ENTRIES();
 }
 /* }}} */
 
 /* {{{ SeasClick_module_entry
  */
-zend_module_entry SeasClick_module_entry = {
-	STANDARD_MODULE_HEADER,
-	SEASCLICK_RES_NAME,
-	SeasClick_functions,
-	PHP_MINIT(SeasClick),
-	PHP_MSHUTDOWN(SeasClick),
-	PHP_RINIT(SeasClick),
-	PHP_RSHUTDOWN(SeasClick),
-	PHP_MINFO(SeasClick),
-	PHP_SEASCLICK_VERSION,
-	STANDARD_MODULE_PROPERTIES
+zend_module_entry SeasClick_module_entry =
+{
+    STANDARD_MODULE_HEADER,
+    SEASCLICK_RES_NAME,
+    SeasClick_functions,
+    PHP_MINIT(SeasClick),
+    PHP_MSHUTDOWN(SeasClick),
+    PHP_RINIT(SeasClick),
+    PHP_RSHUTDOWN(SeasClick),
+    PHP_MINFO(SeasClick),
+    PHP_SEASCLICK_VERSION,
+    STANDARD_MODULE_PROPERTIES
 };
 /* }}} */
 
@@ -181,14 +183,15 @@ PHP_METHOD(SEASCLICK_RES_NAME, __construct)
     zval *connectParames;
 
 #ifndef FAST_ZPP
-    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &connectParames) == FAILURE) {
+    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &connectParames) == FAILURE)
+    {
         return;
     }
 #else
 #undef IS_UNDEF
 #define IS_UNDEF Z_EXPECTED_LONG
     ZEND_PARSE_PARAMETERS_START(1, 1)
-        Z_PARAM_ARRAY(connectParames)
+    Z_PARAM_ARRAY(connectParames)
     ZEND_PARSE_PARAMETERS_END();
 #undef IS_UNDEF
 #define IS_UNDEF 0
@@ -222,10 +225,11 @@ PHP_METHOD(SEASCLICK_RES_NAME, __construct)
     zval *compression = sc_zend_read_property(SeasClick_ce, this_obj, "compression", sizeof("compression") - 1, 0);
 
     ClientOptions Options = ClientOptions()
-                                .SetHost(Z_STRVAL_P(host))
-                                .SetPort(Z_LVAL_P(port))
-                                .SetPingBeforeQuery(false);
-    if (Z_TYPE_P(compression) == IS_TRUE) {
+                            .SetHost(Z_STRVAL_P(host))
+                            .SetPort(Z_LVAL_P(port))
+                            .SetPingBeforeQuery(false);
+    if (Z_TYPE_P(compression) == IS_TRUE)
+    {
         Options = Options.SetCompressionMethod(CompressionMethod::LZ4);
     }
 
@@ -250,13 +254,16 @@ PHP_METHOD(SEASCLICK_RES_NAME, __construct)
         Options = Options.SetPassword(Z_STRVAL_P(value));
     }
 
-    try {
+    try
+    {
         Client *client = new Client(Options);
         int key = Z_OBJ_HANDLE(*this_obj);
 
         clientMap.insert(std::pair<int, Client*>(key, client));
 
-    } catch (const std::exception& e) {
+    }
+    catch (const std::exception& e)
+    {
         sc_zend_throw_exception(NULL, e.what(), 0 TSRMLS_CC);
     }
 
@@ -280,9 +287,12 @@ void getInsertSql(string *sql, char *table_name, zval *columns)
     SC_HASHTABLE_FOREACH_START2(columns_ht, key, keylen, keytype, pzval)
     {
         convert_to_string(pzval);
-        if (index >= (count - 1)) {
+        if (index >= (count - 1))
+        {
             fields_section << (string)Z_STRVAL_P(pzval);
-        } else {
+        }
+        else
+        {
             fields_section << (string)Z_STRVAL_P(pzval) << ",";
         }
         index++;
@@ -300,24 +310,28 @@ PHP_METHOD(SEASCLICK_RES_NAME, select)
     zval* params = NULL;
 
 #ifndef FAST_ZPP
-    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &sql, &l_sql, &params) == FAILURE) {
+    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &sql, &l_sql, &params) == FAILURE)
+    {
         return;
     }
 #else
 #undef IS_UNDEF
 #define IS_UNDEF Z_EXPECTED_LONG
     ZEND_PARSE_PARAMETERS_START(1, 2)
-        Z_PARAM_STRING(sql, l_sql)
-        Z_PARAM_OPTIONAL
-        Z_PARAM_ARRAY(params)
+    Z_PARAM_STRING(sql, l_sql)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_ARRAY(params)
     ZEND_PARSE_PARAMETERS_END();
 #undef IS_UNDEF
 #define IS_UNDEF 0
 #endif
-    try {
+    try
+    {
         string sql_s = (string)sql;
-        if (ZEND_NUM_ARGS() > 1 && params != NULL) {
-            if (Z_TYPE_P(params) != IS_ARRAY) {
+        if (ZEND_NUM_ARGS() > 1 && params != NULL)
+        {
+            if (Z_TYPE_P(params) != IS_ARRAY)
+            {
                 throw std::runtime_error("The second argument to the select function must be an array");
             }
 
@@ -341,21 +355,25 @@ PHP_METHOD(SEASCLICK_RES_NAME, select)
         array_init(return_value);
 
         client->Select(sql_s, [return_value](const Block& block)
+        {
+            zval *return_tmp;
+            for (size_t row = 0; row < block.GetRowCount(); ++row)
             {
-                zval *return_tmp;
-                for (size_t row = 0; row < block.GetRowCount(); ++row) {
-                    SC_MAKE_STD_ZVAL(return_tmp);
-                    array_init(return_tmp);
-                    for (size_t column = 0; column < block.GetColumnCount(); ++column) {
-                        string column_name = block.GetColumnName(column);
-                        convertToZval(return_tmp, block[column], row, column_name, 0);
-                    }
-                    add_next_index_zval(return_value, return_tmp);
+                SC_MAKE_STD_ZVAL(return_tmp);
+                array_init(return_tmp);
+                for (size_t column = 0; column < block.GetColumnCount(); ++column)
+                {
+                    string column_name = block.GetColumnName(column);
+                    convertToZval(return_tmp, block[column], row, column_name, 0);
                 }
+                add_next_index_zval(return_value, return_tmp);
             }
-        );
+        }
+                      );
 
-    } catch (const std::exception& e) {
+    }
+    catch (const std::exception& e)
+    {
         sc_zend_throw_exception(NULL, e.what(), 0 TSRMLS_CC);
     }
 }
@@ -373,22 +391,24 @@ PHP_METHOD(SEASCLICK_RES_NAME, insert)
     string sql;
 
 #ifndef FAST_ZPP
-    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szz", &table, &l_table, &columns, &values) == FAILURE) {
+    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szz", &table, &l_table, &columns, &values) == FAILURE)
+    {
         return;
     }
 #else
 #undef IS_UNDEF
 #define IS_UNDEF Z_EXPECTED_LONG
     ZEND_PARSE_PARAMETERS_START(3, 3)
-        Z_PARAM_STRING(table, l_table)
-        Z_PARAM_ARRAY(columns)
-        Z_PARAM_ARRAY(values)
+    Z_PARAM_STRING(table, l_table)
+    Z_PARAM_ARRAY(columns)
+    Z_PARAM_ARRAY(values)
     ZEND_PARSE_PARAMETERS_END();
 #undef IS_UNDEF
 #define IS_UNDEF 0
 #endif
 
-    try {
+    try
+    {
         HashTable *columns_ht = Z_ARRVAL_P(columns);
         HashTable *values_ht = Z_ARRVAL_P(values);
         size_t columns_count = zend_hash_num_elements(columns_ht);
@@ -411,11 +431,13 @@ PHP_METHOD(SEASCLICK_RES_NAME, insert)
 
             SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, pzval)
             {
-                if (Z_TYPE_P(pzval) != IS_ARRAY) {
+                if (Z_TYPE_P(pzval) != IS_ARRAY)
+                {
                     throw std::runtime_error("The insert function needs to pass in a two-dimensional array");
                 }
                 fzval = sc_zend_hash_index_find(Z_ARRVAL_P(pzval), i);
-                if (NULL == fzval) {
+                if (NULL == fzval)
+                {
                     throw std::runtime_error("The number of parameters inserted per line is inconsistent");
                 }
                 sc_zval_add_ref(fzval);
@@ -432,11 +454,12 @@ PHP_METHOD(SEASCLICK_RES_NAME, insert)
         int key = Z_OBJ_HANDLE(*getThis());
         Client *client = clientMap.at(key);
 
-        client->InsertQuery(sql, [&blockQuery](const Block& block) {
-                blockQuery = block;
-            }
-        );
-        
+        client->InsertQuery(sql, [&blockQuery](const Block& block)
+        {
+            blockQuery = block;
+        }
+                           );
+
         Block blockInsert;
         size_t index = 0;
 
@@ -450,7 +473,9 @@ PHP_METHOD(SEASCLICK_RES_NAME, insert)
         client->InsertData(blockInsert);
         sc_zval_ptr_dtor(&return_should);
 
-    } catch (const std::exception& e) {
+    }
+    catch (const std::exception& e)
+    {
         sc_zend_throw_exception(NULL, e.what(), 0 TSRMLS_CC);
     }
     RETURN_TRUE;
@@ -466,25 +491,29 @@ PHP_METHOD(SEASCLICK_RES_NAME, execute)
     zval* params = NULL;
 
 #ifndef FAST_ZPP
-    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &sql, &l_sql, &params) == FAILURE) {
+    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &sql, &l_sql, &params) == FAILURE)
+    {
         return;
     }
 #else
 #undef IS_UNDEF
 #define IS_UNDEF Z_EXPECTED_LONG
     ZEND_PARSE_PARAMETERS_START(1, 2)
-        Z_PARAM_STRING(sql, l_sql)
-        Z_PARAM_OPTIONAL
-        Z_PARAM_ARRAY(params)
+    Z_PARAM_STRING(sql, l_sql)
+    Z_PARAM_OPTIONAL
+    Z_PARAM_ARRAY(params)
     ZEND_PARSE_PARAMETERS_END();
 #undef IS_UNDEF
 #define IS_UNDEF 0
 #endif
 
-    try {
+    try
+    {
         string sql_s = (string)sql;
-        if (ZEND_NUM_ARGS() > 1 && params != NULL) {
-            if (Z_TYPE_P(params) != IS_ARRAY) {
+        if (ZEND_NUM_ARGS() > 1 && params != NULL)
+        {
+            if (Z_TYPE_P(params) != IS_ARRAY)
+            {
                 throw std::runtime_error("The second argument to the select function must be an array");
             }
 
@@ -506,7 +535,9 @@ PHP_METHOD(SEASCLICK_RES_NAME, execute)
         Client *client = clientMap.at(key);
         client->Execute(sql_s);
 
-    } catch (const std::exception& e) {
+    }
+    catch (const std::exception& e)
+    {
         sc_zend_throw_exception(NULL, e.what(), 0 TSRMLS_CC);
     }
     RETURN_TRUE;
@@ -517,13 +548,16 @@ PHP_METHOD(SEASCLICK_RES_NAME, execute)
  */
 PHP_METHOD(SEASCLICK_RES_NAME, __destruct)
 {
-    try {
+    try
+    {
         int key = Z_OBJ_HANDLE(*getThis());
         Client *client = clientMap.at(key);
         delete client;
         clientMap.erase(key);
 
-    } catch (const std::exception& e) {
+    }
+    catch (const std::exception& e)
+    {
         sc_zend_throw_exception(NULL, e.what(), 0 TSRMLS_CC);
     }
     RETURN_TRUE;
diff --git a/config.w32 b/config.w32.without
similarity index 100%
rename from config.w32
rename to config.w32.without
diff --git a/package.xml b/package.xml
index 30c813d..c4756ab 100644
--- a/package.xml
+++ b/package.xml
@@ -12,7 +12,7 @@
         <email>neeke@php.net</email>
         <active>yes</active>
     </lead>
-    <date>2019-03-24</date>
+    <date>2019-03-28</date>
     <time>13:00:00</time>
     <version>
         <release>0.1.0</release>
@@ -32,7 +32,7 @@
             <file role="doc" name="README.md" />
             <file role="doc" name="LICENSE" />
             <file role="src" name="config.m4" />
-            <file role="src" name="config.w32" />
+            <file role="src" name="config.w32.without" />
             <file role="src" name="EXPERIMENTAL" />
             <file role="src" name="php_SeasClick.h" />
             <file role="src" name="php7_wrapper.h" />
diff --git a/typesToPhp.cpp b/typesToPhp.cpp
index 0c9a0fe..0f620d1 100644
--- a/typesToPhp.cpp
+++ b/typesToPhp.cpp
@@ -46,128 +46,134 @@ ColumnRef createColumn(TypeRef type)
 {
     switch (type->GetCode())
     {
-        case Type::Code::UInt64:
-        {
-            return std::make_shared<ColumnUInt64>();
-        }
-        case Type::Code::UInt8:
-        {
-            return std::make_shared<ColumnUInt8>();
-        }
-        case Type::Code::UInt16:
-        {
-            return std::make_shared<ColumnUInt16>();
-        }
-        case Type::Code::UInt32:
-        {
-            return std::make_shared<ColumnUInt32>();
-        }
+    case Type::Code::UInt64:
+    {
+        return std::make_shared<ColumnUInt64>();
+    }
+    case Type::Code::UInt8:
+    {
+        return std::make_shared<ColumnUInt8>();
+    }
+    case Type::Code::UInt16:
+    {
+        return std::make_shared<ColumnUInt16>();
+    }
+    case Type::Code::UInt32:
+    {
+        return std::make_shared<ColumnUInt32>();
+    }
 
-        case Type::Code::Int8:
-        {
-            return std::make_shared<ColumnInt8>();
-        }
-        case Type::Code::Int16:
-        {
-            return std::make_shared<ColumnInt16>();
-        }
-        case Type::Code::Int32:
-        {
-            return std::make_shared<ColumnInt32>();
-        }
-        case Type::Code::Int64:
-        {
-            return std::make_shared<ColumnInt64>();
-        }
+    case Type::Code::Int8:
+    {
+        return std::make_shared<ColumnInt8>();
+    }
+    case Type::Code::Int16:
+    {
+        return std::make_shared<ColumnInt16>();
+    }
+    case Type::Code::Int32:
+    {
+        return std::make_shared<ColumnInt32>();
+    }
+    case Type::Code::Int64:
+    {
+        return std::make_shared<ColumnInt64>();
+    }
 
-        case Type::Code::UUID:
-        {
-            return std::make_shared<ColumnUUID>();
-        }
+    case Type::Code::UUID:
+    {
+        return std::make_shared<ColumnUUID>();
+    }
 
-        case Type::Code::Float32:
-        {
-            return std::make_shared<ColumnFloat32>();
-        }
-        case Type::Code::Float64:
-        {
-            return std::make_shared<ColumnFloat64>();
-        }
+    case Type::Code::Float32:
+    {
+        return std::make_shared<ColumnFloat32>();
+    }
+    case Type::Code::Float64:
+    {
+        return std::make_shared<ColumnFloat64>();
+    }
 
-        case Type::Code::String:
-        {
-            return std::make_shared<ColumnString>();
-        }
-        case Type::Code::FixedString:
-        {
-            string typeName = type->GetName();
-            typeName.erase(typeName.find("FixedString("), 12);
-            typeName.erase(typeName.find(")"), 1);
-            return std::make_shared<ColumnFixedString>(std::stoi(typeName));
-        }
+    case Type::Code::String:
+    {
+        return std::make_shared<ColumnString>();
+    }
+    case Type::Code::FixedString:
+    {
+        string typeName = type->GetName();
+        typeName.erase(typeName.find("FixedString("), 12);
+        typeName.erase(typeName.find(")"), 1);
+        return std::make_shared<ColumnFixedString>(std::stoi(typeName));
+    }
 
-        case Type::Code::DateTime:
-        {
-            return std::make_shared<ColumnDateTime>();
-        }
-        case Type::Code::Date:
-        {
-            return std::make_shared<ColumnDate>();
-        }
+    case Type::Code::DateTime:
+    {
+        return std::make_shared<ColumnDateTime>();
+    }
+    case Type::Code::Date:
+    {
+        return std::make_shared<ColumnDate>();
+    }
 
-        case Type::Code::Array:
-        {
-            return std::make_shared<ColumnArray>(createColumn(type->GetItemType()));
-        }
+    case Type::Code::Array:
+    {
+        return std::make_shared<ColumnArray>(createColumn(type->GetItemType()));
+    }
 
-        case Type::Code::Enum8:
-        {
-            std::vector<Type::EnumItem> enum_items;
-            
-            auto enumType = EnumType(type);
-            
-            for (auto ei = enumType.BeginValueToName(); ; ) {
-                enum_items.push_back(
-                    Type::EnumItem{ei->second, (int8_t)ei->first});
-                if (++ei == enumType.EndValueToName()) {
-                    break;
-                }
-            }
+    case Type::Code::Enum8:
+    {
+        std::vector<Type::EnumItem> enum_items;
 
-            return std::make_shared<ColumnEnum8>(Type::CreateEnum8(enum_items));
-        }
-        case Type::Code::Enum16:
+        auto enumType = EnumType(type);
+
+        for (auto ei = enumType.BeginValueToName(); ; )
         {
-            std::vector<Type::EnumItem> enum_items;
-            
-            auto enumType = EnumType(type);
-            
-            for (auto ei = enumType.BeginValueToName(); ; ) {
-                enum_items.push_back(
-                    Type::EnumItem{ei->second, (int16_t)ei->first});
-                if (++ei == enumType.EndValueToName()) {
-                    break;
-                }
+            enum_items.push_back(
+                Type::EnumItem {ei->second, (int8_t)ei->first});
+            if (++ei == enumType.EndValueToName())
+            {
+                break;
             }
-
-            return std::make_shared<ColumnEnum16>(Type::CreateEnum16(enum_items));
         }
 
-        case Type::Code::Nullable:
-        {
-            return std::make_shared<ColumnNullable>(createColumn(type->GetNestedType()), std::make_shared<ColumnUInt8>());
-        }
+        return std::make_shared<ColumnEnum8>(Type::CreateEnum8(enum_items));
+    }
+    case Type::Code::Enum16:
+    {
+        std::vector<Type::EnumItem> enum_items;
 
-        case Type::Code::Tuple:
-        {
-            throw std::runtime_error("can't support Tuple");
-        }
+        auto enumType = EnumType(type);
 
-        case Type::Code::Void:
+        for (auto ei = enumType.BeginValueToName(); ; )
         {
-            throw std::runtime_error("can't support Void");
+            enum_items.push_back(
+                Type::EnumItem {ei->second, (int16_t)ei->first});
+            if (++ei == enumType.EndValueToName())
+            {
+                break;
+            }
         }
+
+        return std::make_shared<ColumnEnum16>(Type::CreateEnum16(enum_items));
     }
+
+    case Type::Code::Nullable:
+    {
+        return std::make_shared<ColumnNullable>(createColumn(type->GetNestedType()), std::make_shared<ColumnUInt8>());
+    }
+
+    case Type::Code::Tuple:
+    {
+        throw std::runtime_error("can't support Tuple");
+    }
+
+    case Type::Code::Void:
+    {
+        throw std::runtime_error("can't support Void");
+    }
+    }
+
+    throw std::runtime_error("createColumn runtime error.");
 }
 
 ColumnRef insertColumn(TypeRef type, zval *value_zval)
@@ -181,596 +187,678 @@ ColumnRef insertColumn(TypeRef type, zval *value_zval)
 
     switch (type->GetCode())
     {
-        case Type::Code::UInt64:
-        {
-            auto value = std::make_shared<ColumnUInt64>();
-            
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
-            {
-                convert_to_long(array_value);
-                value->Append(Z_LVAL_P(array_value));
-            }
-            SC_HASHTABLE_FOREACH_END();
+    case Type::Code::UInt64:
+    {
+        auto value = std::make_shared<ColumnUInt64>();
 
-            return value;
-            break;
-        }
-        case Type::Code::UInt8:
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
         {
-            auto value = std::make_shared<ColumnUInt8>();
+            convert_to_long(array_value);
+            value->Append(Z_LVAL_P(array_value));
+        }
+        SC_HASHTABLE_FOREACH_END();
 
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
-            {
-                convert_to_long(array_value);
-                value->Append(Z_LVAL_P(array_value));
-            }
-            SC_HASHTABLE_FOREACH_END();
+        return value;
+        break;
+    }
+    case Type::Code::UInt8:
+    {
+        auto value = std::make_shared<ColumnUInt8>();
 
-            return value;
-            break;
-        }
-        case Type::Code::UInt16:
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
         {
-            auto value = std::make_shared<ColumnUInt16>();
-
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
-            {
-                convert_to_long(array_value);
-                value->Append(Z_LVAL_P(array_value));
-            }
-            SC_HASHTABLE_FOREACH_END();
-            
-            return value;
-            break;
+            convert_to_long(array_value);
+            value->Append(Z_LVAL_P(array_value));
         }
-        case Type::Code::UInt32:
-        {
-            auto value = std::make_shared<ColumnUInt32>();
+        SC_HASHTABLE_FOREACH_END();
 
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
-            {
-                convert_to_long(array_value);
-                value->Append(Z_LVAL_P(array_value));
-            }
-            SC_HASHTABLE_FOREACH_END();
-            
-            return value;
-            break;
-        }
+        return value;
+        break;
+    }
+    case Type::Code::UInt16:
+    {
+        auto value = std::make_shared<ColumnUInt16>();
 
-        case Type::Code::Int8:
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
         {
-            auto value = std::make_shared<ColumnInt8>();
-
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
-            {
-                convert_to_long(array_value);
-                value->Append(Z_LVAL_P(array_value));
-            }
-            SC_HASHTABLE_FOREACH_END();
-            
-            return value;
-            break;
+            convert_to_long(array_value);
+            value->Append(Z_LVAL_P(array_value));
         }
-        case Type::Code::Int16:
-        {
-            auto value = std::make_shared<ColumnInt16>();
+        SC_HASHTABLE_FOREACH_END();
 
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
-            {
-                convert_to_long(array_value);
-                value->Append(Z_LVAL_P(array_value));
-            }
-            SC_HASHTABLE_FOREACH_END();
-            
-            return value;
-            break;
-        }
-        case Type::Code::Int32:
+        return value;
+        break;
+    }
+    case Type::Code::UInt32:
+    {
+        auto value = std::make_shared<ColumnUInt32>();
+
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
         {
-            auto value = std::make_shared<ColumnInt32>();
+            convert_to_long(array_value);
+            value->Append(Z_LVAL_P(array_value));
+        }
+        SC_HASHTABLE_FOREACH_END();
 
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
-            {
-                convert_to_long(array_value);
-                value->Append(Z_LVAL_P(array_value));
-            }
-            SC_HASHTABLE_FOREACH_END();
-            
-            return value;
-            break;
+        return value;
+        break;
+    }
+
+    case Type::Code::Int8:
+    {
+        auto value = std::make_shared<ColumnInt8>();
+
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+        {
+            convert_to_long(array_value);
+            value->Append(Z_LVAL_P(array_value));
         }
-        case Type::Code::Int64:
+        SC_HASHTABLE_FOREACH_END();
+
+        return value;
+        break;
+    }
+    case Type::Code::Int16:
+    {
+        auto value = std::make_shared<ColumnInt16>();
+
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
         {
-            auto value = std::make_shared<ColumnInt64>();
+            convert_to_long(array_value);
+            value->Append(Z_LVAL_P(array_value));
+        }
+        SC_HASHTABLE_FOREACH_END();
 
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
-            {
-                convert_to_long(array_value);
-                value->Append(Z_LVAL_P(array_value));
-            }
-            SC_HASHTABLE_FOREACH_END();
-            
-            return value;
-            break;
+        return value;
+        break;
+    }
+    case Type::Code::Int32:
+    {
+        auto value = std::make_shared<ColumnInt32>();
+
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+        {
+            convert_to_long(array_value);
+            value->Append(Z_LVAL_P(array_value));
         }
+        SC_HASHTABLE_FOREACH_END();
+
+        return value;
+        break;
+    }
+    case Type::Code::Int64:
+    {
+        auto value = std::make_shared<ColumnInt64>();
 
-        case Type::Code::UUID:
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
         {
-            auto value = std::make_shared<ColumnUUID>();
+            convert_to_long(array_value);
+            value->Append(Z_LVAL_P(array_value));
+        }
+        SC_HASHTABLE_FOREACH_END();
+
+        return value;
+        break;
+    }
 
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+    case Type::Code::UUID:
+    {
+        auto value = std::make_shared<ColumnUUID>();
+
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+        {
+            if (Z_TYPE_P(array_value) == IS_NULL)
             {
-                if (Z_TYPE_P(array_value) == IS_NULL) {
-                    value->Append(UInt128(0, 0));
-                } else {
-                    convert_to_string(array_value);
-                    string value_string = (string)Z_STRVAL_P(array_value);
-
-                    value_string.erase(std::remove(value_string.begin(), value_string.end(), '-'), value_string.end());
-                    if (value_string.length() != 32) {
-                        throw std::runtime_error("UUID format error");
-                    }
-
-                    string first = value_string.substr(0, 16);
-                    string second = value_string.substr(16, 16);
-                    uint64_t i_first = std::stoull(first, nullptr, 16);
-                    uint64_t i_second = std::stoull(second, nullptr, 16);
-                    value->Append(UInt128(i_first, i_second));
+                value->Append(UInt128(0, 0));
+            }
+            else
+            {
+                convert_to_string(array_value);
+                string value_string = (string)Z_STRVAL_P(array_value);
+
+                value_string.erase(std::remove(value_string.begin(), value_string.end(), '-'), value_string.end());
+                if (value_string.length() != 32)
+                {
+                    throw std::runtime_error("UUID format error");
                 }
+
+                string first = value_string.substr(0, 16);
+                string second = value_string.substr(16, 16);
+                uint64_t i_first = std::stoull(first, nullptr, 16);
+                uint64_t i_second = std::stoull(second, nullptr, 16);
+                value->Append(UInt128(i_first, i_second));
             }
-            SC_HASHTABLE_FOREACH_END();
-            return value;
-            break;
         }
+        SC_HASHTABLE_FOREACH_END();
+        return value;
+        break;
+    }
 
-        case Type::Code::Float32:
+    case Type::Code::Float32:
+    {
+        auto value = std::make_shared<ColumnFloat32>();
+
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
         {
-            auto value = std::make_shared<ColumnFloat32>();
+            convert_to_double(array_value);
+            value->Append(Z_DVAL_P(array_value));
+        }
+        SC_HASHTABLE_FOREACH_END();
 
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
-            {
-                convert_to_double(array_value);
-                value->Append(Z_DVAL_P(array_value));
-            }
-            SC_HASHTABLE_FOREACH_END();
+        return value;
+        break;
+    }
+    case Type::Code::Float64:
+    {
+        auto value = std::make_shared<ColumnFloat64>();
 
-            return value;
-            break;
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+        {
+            convert_to_double(array_value);
+            value->Append(Z_DVAL_P(array_value));
         }
-        case Type::Code::Float64:
+        SC_HASHTABLE_FOREACH_END();
+
+        return value;
+        break;
+    }
+
+    case Type::Code::String:
+    {
+        auto value = std::make_shared<ColumnString>();
+
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
         {
-            auto value = std::make_shared<ColumnFloat64>();
+            convert_to_string(array_value);
+            value->Append((string)Z_STRVAL_P(array_value));
+        }
+        SC_HASHTABLE_FOREACH_END();
 
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
-            {
-                convert_to_double(array_value);
-                value->Append(Z_DVAL_P(array_value));
-            }
-            SC_HASHTABLE_FOREACH_END();
+        return value;
+    }
+    case Type::Code::FixedString:
+    {
+        string typeName = type->GetName();
+        typeName.erase(typeName.find("FixedString("), 12);
+        typeName.erase(typeName.find(")"), 1);
+        auto value = std::make_shared<ColumnFixedString>(std::stoi(typeName));
 
-            return value;
-            break;
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+        {
+            convert_to_string(array_value);
+            value->Append((string)Z_STRVAL_P(array_value));
         }
+        SC_HASHTABLE_FOREACH_END();
+
+        return value;
+    }
+
+    case Type::Code::DateTime:
+    {
+        auto value = std::make_shared<ColumnDateTime>();
 
-        case Type::Code::String:
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
         {
-            auto value = std::make_shared<ColumnString>();
+            convert_to_long(array_value);
+            value->Append(Z_LVAL_P(array_value));
+        }
+        SC_HASHTABLE_FOREACH_END();
 
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
-            {
-                convert_to_string(array_value);
-                value->Append((string)Z_STRVAL_P(array_value));
-            }
-            SC_HASHTABLE_FOREACH_END();
+        return value;
+        break;
+    }
+    case Type::Code::Date:
+    {
+        auto value = std::make_shared<ColumnDate>();
 
-            return value;
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+        {
+            convert_to_long(array_value);
+            value->Append(Z_LVAL_P(array_value));
         }
-        case Type::Code::FixedString:
+        SC_HASHTABLE_FOREACH_END();
+
+        return value;
+        break;
+    }
+
+    case Type::Code::Array:
+    {
+        if (type->GetItemType()->GetCode() == Type::Array)
         {
-            string typeName = type->GetName();
-            typeName.erase(typeName.find("FixedString("), 12);
-            typeName.erase(typeName.find(")"), 1);
-            auto value = std::make_shared<ColumnFixedString>(std::stoi(typeName));
+            throw std::runtime_error("can't support Multidimensional Arrays");
+        }
+
+        auto value = std::make_shared<ColumnArray>(createColumn(type->GetItemType()));
+        auto child = createColumn(type->GetItemType());
 
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+        {
+            if (Z_TYPE_P(array_value) != IS_ARRAY)
             {
-                convert_to_string(array_value);
-                value->Append((string)Z_STRVAL_P(array_value));
+                throw std::runtime_error("The inserted data is not an array type");
             }
-            SC_HASHTABLE_FOREACH_END();
 
-            return value;
+            child->Append(insertColumn(type->GetItemType(), array_value));
+
+            value->AppendAsColumn(child);
+            child->Clear();
         }
+        SC_HASHTABLE_FOREACH_END();
 
-        case Type::Code::DateTime:
-        {
-            auto value = std::make_shared<ColumnDateTime>();
+        return value;
+        break;
+    }
+
+    case Type::Code::Enum8:
+    {
+        std::vector<Type::EnumItem> enum_items;
+
+        auto enumType = EnumType(type);
 
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+        for (auto ei = enumType.BeginValueToName(); ; )
+        {
+            enum_items.push_back(
+                Type::EnumItem {ei->second, (int8_t)ei->first});
+            if (++ei == enumType.EndValueToName())
             {
-                convert_to_long(array_value);
-                value->Append(Z_LVAL_P(array_value));
+                break;
             }
-            SC_HASHTABLE_FOREACH_END();
-            
-            return value;
-            break;
         }
-        case Type::Code::Date:
-        {
-            auto value = std::make_shared<ColumnDate>();
 
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+        auto value = std::make_shared<ColumnEnum8>(Type::CreateEnum8(enum_items));
+
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+        {
+            if (Z_TYPE_P(array_value) == IS_LONG)
             {
                 convert_to_long(array_value);
                 value->Append(Z_LVAL_P(array_value));
             }
-            SC_HASHTABLE_FOREACH_END();
-            
-            return value;
-            break;
+            else
+            {
+                convert_to_string(array_value);
+                value->Append((string)Z_STRVAL_P(array_value));
+            }
         }
+        SC_HASHTABLE_FOREACH_END();
 
-        case Type::Code::Array:
-        {
-            if (type->GetItemType()->GetCode() == Type::Array) {
-                throw std::runtime_error("can't support Multidimensional Arrays");
-            }
+        return value;
+        break;
+    }
+    case Type::Code::Enum16:
+    {
+        std::vector<Type::EnumItem> enum_items;
 
-            auto value = std::make_shared<ColumnArray>(createColumn(type->GetItemType()));
-            auto child = createColumn(type->GetItemType());
+        auto enumType = EnumType(type);
 
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+        for (auto ei = enumType.BeginValueToName(); ; )
+        {
+            enum_items.push_back(
+                Type::EnumItem {ei->second, (int16_t)ei->first});
+            if (++ei == enumType.EndValueToName())
             {
-                if (Z_TYPE_P(array_value) != IS_ARRAY) {
-                    throw std::runtime_error("The inserted data is not an array type");
-                }
-
-                child->Append(insertColumn(type->GetItemType(), array_value));
-
-                value->AppendAsColumn(child);
-                child->Clear();
-            }
-            SC_HASHTABLE_FOREACH_END();
-            
-            return value;
-            break;
-        }
-
-        case Type::Code::Enum8:
-        {
-            std::vector<Type::EnumItem> enum_items;
-            
-            auto enumType = EnumType(type);
-            
-            for (auto ei = enumType.BeginValueToName(); ; ) {
-                enum_items.push_back(
-                    Type::EnumItem{ei->second, (int8_t)ei->first});
-                if (++ei == enumType.EndValueToName()) {
-                    break;
-                }
+                break;
             }
+        }
 
-            auto value = std::make_shared<ColumnEnum8>(Type::CreateEnum8(enum_items));
+        auto value = std::make_shared<ColumnEnum16>(Type::CreateEnum16(enum_items));
 
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+        {
+            if (Z_TYPE_P(array_value) == IS_LONG)
             {
-                if (Z_TYPE_P(array_value) == IS_LONG) {
-                    convert_to_long(array_value);
-                    value->Append(Z_LVAL_P(array_value));
-                } else {
-                    convert_to_string(array_value);
-                    value->Append((string)Z_STRVAL_P(array_value));
-                }
-            }
-            SC_HASHTABLE_FOREACH_END();
-
-            return value;
-            break;
-        }
-        case Type::Code::Enum16:
-        {
-            std::vector<Type::EnumItem> enum_items;
-            
-            auto enumType = EnumType(type);
-            
-            for (auto ei = enumType.BeginValueToName(); ; ) {
-                enum_items.push_back(
-                    Type::EnumItem{ei->second, (int16_t)ei->first});
-                if (++ei == enumType.EndValueToName()) {
-                    break;
-                }
+                convert_to_long(array_value);
+                value->Append(Z_LVAL_P(array_value));
             }
-
-            auto value = std::make_shared<ColumnEnum16>(Type::CreateEnum16(enum_items));
-
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+            else
             {
-                if (Z_TYPE_P(array_value) == IS_LONG) {
-                    convert_to_long(array_value);
-                    value->Append(Z_LVAL_P(array_value));
-                } else {
-                    convert_to_string(array_value);
-                    value->Append((string)Z_STRVAL_P(array_value));
-                }
+                convert_to_string(array_value);
+                value->Append((string)Z_STRVAL_P(array_value));
             }
-            SC_HASHTABLE_FOREACH_END();
-
-            return value;
-            break;
         }
+        SC_HASHTABLE_FOREACH_END();
 
-        case Type::Code::Nullable:
-        {
-            auto nulls = std::make_shared<ColumnUInt8>();
+        return value;
+        break;
+    }
+
+    case Type::Code::Nullable:
+    {
+        auto nulls = std::make_shared<ColumnUInt8>();
 
-            SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+        SC_HASHTABLE_FOREACH_START2(values_ht, str_key, str_keylen, keytype, array_value)
+        {
+            if (Z_TYPE_P(array_value) == IS_NULL)
             {
-                if (Z_TYPE_P(array_value) == IS_NULL) {
-                    nulls->Append(1);
-                } else {
-                    nulls->Append(0);
-                }
+                nulls->Append(1);
+            }
+            else
+            {
+                nulls->Append(0);
             }
-            SC_HASHTABLE_FOREACH_END();
+        }
+        SC_HASHTABLE_FOREACH_END();
 
-            ColumnRef child = insertColumn(type->GetNestedType(), value_zval);
+        ColumnRef child = insertColumn(type->GetNestedType(), value_zval);
 
-            return std::make_shared<ColumnNullable>(child, nulls);
-            break;
-        }
+        return std::make_shared<ColumnNullable>(child, nulls);
+        break;
+    }
 
-        case Type::Code::Tuple:
-        {
-            throw std::runtime_error("can't support Tuple");
-        }
+    case Type::Code::Tuple:
+    {
+        throw std::runtime_error("can't support Tuple");
+    }
 
-        case Type::Code::Void:
-        {
-            throw std::runtime_error("can't support Void");
-        }
+    case Type::Code::Void:
+    {
+        throw std::runtime_error("can't support Void");
+    }
     }
+
+    throw std::runtime_error("insertColumn runtime error.");
 }
 
 void convertToZval(zval *arr, const ColumnRef& columnRef, int row, string column_name, int8_t is_array)
 {
     switch (columnRef->Type()->GetCode())
     {
-        case Type::Code::UInt64:
+    case Type::Code::UInt64:
+    {
+        auto col = (*columnRef->As<ColumnUInt64>())[row];
+        if (is_array)
         {
-            auto col = (*columnRef->As<ColumnUInt64>())[row];
-            if (is_array) {
-                add_next_index_long(arr, (long)col);
-            } else {
-                sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col);
-            }
-            break;
+            add_next_index_long(arr, (long)col);
         }
-        case Type::Code::UInt8:
+        else
         {
-            auto col = (*columnRef->As<ColumnUInt8>())[row];
-            if (is_array) {
-                add_next_index_long(arr, (long)col);
-            } else {
-                sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col);
-            }
-            break;
+            sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col);
         }
-        case Type::Code::UInt16:
+        break;
+    }
+    case Type::Code::UInt8:
+    {
+        auto col = (*columnRef->As<ColumnUInt8>())[row];
+        if (is_array)
         {
-            auto col = (*columnRef->As<ColumnUInt16>())[row];
-            if (is_array) {
-                add_next_index_long(arr, (long)col);
-            } else {
-                sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col);
-            }
-            break;
+            add_next_index_long(arr, (long)col);
         }
-        case Type::Code::UInt32:
+        else
         {
-            auto col = (*columnRef->As<ColumnUInt32>())[row];
-            if (is_array) {
-                add_next_index_long(arr, (long)col);
-            } else {
-                sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col);
-            }
-            break;
+            sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col);
         }
-
-        case Type::Code::Int8:
+        break;
+    }
+    case Type::Code::UInt16:
+    {
+        auto col = (*columnRef->As<ColumnUInt16>())[row];
+        if (is_array)
         {
-            auto col = (*columnRef->As<ColumnInt8>())[row];
-            if (is_array) {
-                add_next_index_long(arr, (long)col);
-            } else {
-                sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col);
-            }
-            break;
+            add_next_index_long(arr, (long)col);
         }
-        case Type::Code::Int16:
+        else
         {
-            auto col = (*columnRef->As<ColumnInt16>())[row];
-            if (is_array) {
-                add_next_index_long(arr, (long)col);
-            } else {
-                sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col);
-            }
-            break;
+            sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col);
         }
-        case Type::Code::Int32:
+        break;
+    }
+    case Type::Code::UInt32:
+    {
+        auto col = (*columnRef->As<ColumnUInt32>())[row];
+        if (is_array)
         {
-            auto col = (*columnRef->As<ColumnInt32>())[row];
-            if (is_array) {
-                add_next_index_long(arr, (long)col);
-            } else {
-                sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col);
-            }
-            break;
+            add_next_index_long(arr, (long)col);
         }
-        case Type::Code::Int64:
+        else
         {
-            auto col = (*columnRef->As<ColumnInt64>())[row];
-            if (is_array) {
-                add_next_index_long(arr, (long)col);
-            } else {
-                sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col);
-            }
-            break;
+            sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col);
         }
+        break;
+    }
 
-        case Type::Code::UUID:
+    case Type::Code::Int8:
+    {
+        auto col = (*columnRef->As<ColumnInt8>())[row];
+        if (is_array)
         {
-            stringstream first;
-            stringstream second;
-            auto col = (*columnRef->As<ColumnUUID>())[row];
-            first<<std::setw(16)<<std::setfill('0')<<hex<<col.first;
-            second<<std::setw(16)<<std::setfill('0')<<hex<<col.second;
-            if (is_array) {
-                sc_add_next_index_stringl(arr, (char*)(first.str() + second.str()).c_str(), (first.str() + second.str()).length(), 1);
-            } else {
-                sc_add_assoc_stringl_ex(arr, column_name.c_str(), column_name.length(), (char*)(first.str() + second.str()).c_str(), (first.str() + second.str()).length(), 1);
-            }
-            break;
+            add_next_index_long(arr, (long)col);
         }
-
-        case Type::Code::Float32:
+        else
         {
-            auto col = (*columnRef->As<ColumnFloat32>())[row];
-            stringstream stream;
-            stream<<col;
-            double d;
-            stream>>d;
-            if (is_array) {
-                add_next_index_double(arr, d);
-            } else {
-                sc_add_assoc_double_ex(arr, column_name.c_str(), column_name.length(), d);
-            }
-            break;
+            sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col);
         }
-        case Type::Code::Float64:
+        break;
+    }
+    case Type::Code::Int16:
+    {
+        auto col = (*columnRef->As<ColumnInt16>())[row];
+        if (is_array)
         {
-            auto col = (*columnRef->As<ColumnFloat64>())[row];
-            if (is_array) {
-                add_next_index_double(arr, (double)col);
-            } else {
-                sc_add_assoc_double_ex(arr, column_name.c_str(), column_name.length(), (double)col);
-            }
-            break;
+            add_next_index_long(arr, (long)col);
+        }
+        else
+        {
+            sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col);
+        }
+        break;
+    }
+    case Type::Code::Int32:
+    {
+        auto col = (*columnRef->As<ColumnInt32>())[row];
+        if (is_array)
+        {
+            add_next_index_long(arr, (long)col);
+        }
+        else
+        {
+            sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col);
+        }
+        break;
+    }
+    case Type::Code::Int64:
+    {
+        auto col = (*columnRef->As<ColumnInt64>())[row];
+        if (is_array)
+        {
+            add_next_index_long(arr, (long)col);
+        }
+        else
+        {
+            sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col);
         }
+        break;
+    }
 
-        case Type::Code::String:
+    case Type::Code::UUID:
+    {
+        stringstream first;
+        stringstream second;
+        auto col = (*columnRef->As<ColumnUUID>())[row];
+        first<<std::setw(16)<<std::setfill('0')<<hex<<col.first;
+        second<<std::setw(16)<<std::setfill('0')<<hex<<col.second;
+        if (is_array)
         {
-            auto col = (*columnRef->As<ColumnString>())[row];
-            if (is_array) {
-                sc_add_next_index_stringl(arr, (char*)col.c_str(), col.length(), 1);
-            } else {
-                sc_add_assoc_stringl_ex(arr, column_name.c_str(), column_name.length(), (char*)col.c_str(), col.length(), 1);
-            }
-            break;
+            sc_add_next_index_stringl(arr, (char*)(first.str() + second.str()).c_str(), (first.str() + second.str()).length(), 1);
         }
-        case Type::Code::FixedString:
+        else
         {
-            auto col = (*columnRef->As<ColumnFixedString>())[row];
-            if (is_array) {
-                sc_add_next_index_stringl(arr, (char*)col.c_str(), col.length(), 1);
-            } else {
-                sc_add_assoc_stringl_ex(arr, column_name.c_str(), column_name.length(), (char*)col.c_str(), strlen((char*)col.c_str()), 1);
-            }
-            break;
+            sc_add_assoc_stringl_ex(arr, column_name.c_str(), column_name.length(), (char*)(first.str() + second.str()).c_str(), (first.str() + second.str()).length(), 1);
         }
+        break;
+    }
 
-        case Type::Code::DateTime:
+    case Type::Code::Float32:
+    {
+        auto col = (*columnRef->As<ColumnFloat32>())[row];
+        stringstream stream;
+        stream<<col;
+        double d;
+        stream>>d;
+        if (is_array)
         {
-            auto col = columnRef->As<ColumnDateTime>();
-            if (is_array) {
-                add_next_index_long(arr, (long)col->As<ColumnDateTime>()->At(row));
-            } else {
-                sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col->As<ColumnDateTime>()->At(row));
-            }
-            break;
+            add_next_index_double(arr, d);
         }
-        case Type::Code::Date:
+        else
         {
-            auto col = columnRef->As<ColumnDate>();
-            if (is_array) {
-                add_next_index_long(arr, (long)col->As<ColumnDate>()->At(row));
-            } else {
-                sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col->As<ColumnDate>()->At(row));
-            }
-            break;
+            sc_add_assoc_double_ex(arr, column_name.c_str(), column_name.length(), d);
+        }
+        break;
+    }
+    case Type::Code::Float64:
+    {
+        auto col = (*columnRef->As<ColumnFloat64>())[row];
+        if (is_array)
+        {
+            add_next_index_double(arr, (double)col);
+        }
+        else
+        {
+            sc_add_assoc_double_ex(arr, column_name.c_str(), column_name.length(), (double)col);
         }
+        break;
+    }
 
-        case Type::Code::Array:
+    case Type::Code::String:
+    {
+        auto col = (*columnRef->As<ColumnString>())[row];
+        if (is_array)
         {
-            auto array = columnRef->As<ColumnArray>();
-            auto col = array->GetAsColumn(row);
-            zval *return_tmp;
-            SC_MAKE_STD_ZVAL(return_tmp);
-            array_init(return_tmp);
-            for (size_t i = 0; i < col->Size(); ++i) {
-                convertToZval(return_tmp, col, i, "array", 1);
-            }
-            if (is_array) {
-                add_next_index_zval(arr, return_tmp);
-            } else {
-                sc_add_assoc_zval_ex(arr, column_name.c_str(), column_name.length(), return_tmp);
-            }
-            break;
+            sc_add_next_index_stringl(arr, (char*)col.c_str(), col.length(), 1);
+        }
+        else
+        {
+            sc_add_assoc_stringl_ex(arr, column_name.c_str(), column_name.length(), (char*)col.c_str(), col.length(), 1);
         }
+        break;
+    }
+    case Type::Code::FixedString:
+    {
+        auto col = (*columnRef->As<ColumnFixedString>())[row];
+        if (is_array)
+        {
+            sc_add_next_index_stringl(arr, (char*)col.c_str(), col.length(), 1);
+        }
+        else
+        {
+            sc_add_assoc_stringl_ex(arr, column_name.c_str(), column_name.length(), (char*)col.c_str(), strlen((char*)col.c_str()), 1);
+        }
+        break;
+    }
 
-        case Type::Code::Enum8:
+    case Type::Code::DateTime:
+    {
+        auto col = columnRef->As<ColumnDateTime>();
+        if (is_array)
         {
-            auto array = columnRef->As<ColumnEnum8>();
-            if (is_array) {
-                sc_add_next_index_stringl(arr, (char*)array->NameAt(row).c_str(), array->NameAt(row).length(), 1);
-            } else {
-                sc_add_assoc_stringl_ex(arr, column_name.c_str(), column_name.length(), (char*)array->NameAt(row).c_str(), array->NameAt(row).length(), 1);
-            }
-            break;
+            add_next_index_long(arr, (long)col->As<ColumnDateTime>()->At(row));
         }
-        case Type::Code::Enum16:
+        else
         {
-            auto array = columnRef->As<ColumnEnum16>();
-            if (is_array) {
-                sc_add_next_index_stringl(arr, (char*)array->NameAt(row).c_str(), array->NameAt(row).length(), 1);
-            } else {
-                sc_add_assoc_stringl_ex(arr, column_name.c_str(), column_name.length(), (char*)array->NameAt(row).c_str(), array->NameAt(row).length(), 1);
-            }
-            break;
+            sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col->As<ColumnDateTime>()->At(row));
+        }
+        break;
+    }
+    case Type::Code::Date:
+    {
+        auto col = columnRef->As<ColumnDate>();
+        if (is_array)
+        {
+            add_next_index_long(arr, (long)col->As<ColumnDate>()->At(row));
+        }
+        else
+        {
+            sc_add_assoc_long_ex(arr, column_name.c_str(), column_name.length(), (zend_ulong)col->As<ColumnDate>()->At(row));
         }
+        break;
+    }
 
-        case Type::Code::Nullable:
+    case Type::Code::Array:
+    {
+        auto array = columnRef->As<ColumnArray>();
+        auto col = array->GetAsColumn(row);
+        zval *return_tmp;
+        SC_MAKE_STD_ZVAL(return_tmp);
+        array_init(return_tmp);
+        for (size_t i = 0; i < col->Size(); ++i)
         {
-            auto nullable = columnRef->As<ColumnNullable>();
-            if (nullable->IsNull(row)) {
-                if (is_array) {
-                    add_next_index_null(arr);
-                } else {
-                    sc_add_assoc_null_ex(arr, column_name.c_str(), column_name.length());
-                }
-            } else {
-                convertToZval(arr, nullable->Nested(), row, column_name, 0);
-            }
-            break;
+            convertToZval(return_tmp, col, i, "array", 1);
+        }
+        if (is_array)
+        {
+            add_next_index_zval(arr, return_tmp);
+        }
+        else
+        {
+            sc_add_assoc_zval_ex(arr, column_name.c_str(), column_name.length(), return_tmp);
         }
+        break;
+    }
 
-        case Type::Code::Tuple:
+    case Type::Code::Enum8:
+    {
+        auto array = columnRef->As<ColumnEnum8>();
+        if (is_array)
         {
-            throw std::runtime_error("can't support Tuple");
+            sc_add_next_index_stringl(arr, (char*)array->NameAt(row).c_str(), array->NameAt(row).length(), 1);
         }
+        else
+        {
+            sc_add_assoc_stringl_ex(arr, column_name.c_str(), column_name.length(), (char*)array->NameAt(row).c_str(), array->NameAt(row).length(), 1);
+        }
+        break;
+    }
+    case Type::Code::Enum16:
+    {
+        auto array = columnRef->As<ColumnEnum16>();
+        if (is_array)
+        {
+            sc_add_next_index_stringl(arr, (char*)array->NameAt(row).c_str(), array->NameAt(row).length(), 1);
+        }
+        else
+        {
+            sc_add_assoc_stringl_ex(arr, column_name.c_str(), column_name.length(), (char*)array->NameAt(row).c_str(), array->NameAt(row).length(), 1);
+        }
+        break;
+    }
 
-        case Type::Code::Void:
+    case Type::Code::Nullable:
+    {
+        auto nullable = columnRef->As<ColumnNullable>();
+        if (nullable->IsNull(row))
         {
-            throw std::runtime_error("can't support Void");
+            if (is_array)
+            {
+                add_next_index_null(arr);
+            }
+            else
+            {
+                sc_add_assoc_null_ex(arr, column_name.c_str(), column_name.length());
+            }
+        }
+        else
+        {
+            convertToZval(arr, nullable->Nested(), row, column_name, 0);
         }
+        break;
+    }
+
+    case Type::Code::Tuple:
+    {
+        throw std::runtime_error("can't support Tuple");
+    }
+
+    case Type::Code::Void:
+    {
+        throw std::runtime_error("can't support Void");
+    }
     }
 }
 
 void zvalToBlock(Block& blockDes, Block& blockSrc, zend_ulong num_key, zval *value_zval)
 {
     ColumnRef column = insertColumn(blockSrc[num_key]->Type(), value_zval);
-    
+
     blockDes.AppendColumn(blockSrc.GetColumnName(num_key), column);
 }