diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..7f6de4d --- /dev/null +++ b/.editorconfig @@ -0,0 +1,345 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. + +# editorconfig.org + +# top-most EditorConfig file +root = true + +# Default settings: +# A newline ending every file +# Use 4 spaces as indentation +[*] +insert_final_newline = true +indent_style = space +indent_size = 4 +trim_trailing_whitespace = true +spelling_exclusion_path = ./exclusion.dic + +[*.json] +indent_size = 2 + +# Generated code +[*{_AssemblyInfo.cs,.notsupported.cs,*/obj/*/External/**/*,*/obj/dotnet-new.IntegrationTests/*/TemplatePackagesPaths.cs}] +generated_code = true + +# C# files +[*.cs] +# New line preferences +csharp_new_line_before_open_brace = all +csharp_new_line_before_else = true +csharp_new_line_before_catch = true +csharp_new_line_before_finally = true +csharp_new_line_before_members_in_object_initializers = true +csharp_new_line_before_members_in_anonymous_types = true +csharp_new_line_between_query_expression_clauses = true + +# Indentation preferences +csharp_indent_block_contents = true +csharp_indent_braces = false +csharp_indent_case_contents = true +csharp_indent_case_contents_when_block = false +csharp_indent_switch_labels = true +csharp_indent_labels = one_less_than_current + +# Modifier preferences +csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:suggestion + +# avoid this. unless absolutely necessary +dotnet_style_qualification_for_field = false:suggestion +dotnet_style_qualification_for_property = false:suggestion +dotnet_style_qualification_for_method = false:suggestion +dotnet_style_qualification_for_event = false:suggestion + +# Types: use keywords instead of BCL types, and permit var only when the type is clear +csharp_style_var_for_built_in_types = false:none +csharp_style_var_when_type_is_apparent = false:none +csharp_style_var_elsewhere = false:none +dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion +dotnet_style_predefined_type_for_member_access = true:suggestion + +# name all constant fields using PascalCase +dotnet_naming_rule.constant_fields_should_be_pascal_case.severity = suggestion +dotnet_naming_rule.constant_fields_should_be_pascal_case.symbols = constant_fields +dotnet_naming_rule.constant_fields_should_be_pascal_case.style = pascal_case_style +dotnet_naming_symbols.constant_fields.applicable_kinds = field +dotnet_naming_symbols.constant_fields.required_modifiers = const +dotnet_naming_style.pascal_case_style.capitalization = pascal_case + +# static fields should have s_ prefix +dotnet_naming_rule.static_fields_should_have_prefix.severity = suggestion +dotnet_naming_rule.static_fields_should_have_prefix.symbols = static_fields +dotnet_naming_rule.static_fields_should_have_prefix.style = static_prefix_style +dotnet_naming_symbols.static_fields.applicable_kinds = field +dotnet_naming_symbols.static_fields.required_modifiers = static +dotnet_naming_symbols.static_fields.applicable_accessibilities = private, internal, private_protected +dotnet_naming_style.static_prefix_style.required_prefix = s_ +dotnet_naming_style.static_prefix_style.capitalization = camel_case + +# internal and private fields should be _camelCase +dotnet_naming_rule.camel_case_for_private_internal_fields.severity = suggestion +dotnet_naming_rule.camel_case_for_private_internal_fields.symbols = private_internal_fields +dotnet_naming_rule.camel_case_for_private_internal_fields.style = camel_case_underscore_style +dotnet_naming_symbols.private_internal_fields.applicable_kinds = field +dotnet_naming_symbols.private_internal_fields.applicable_accessibilities = private, internal +dotnet_naming_style.camel_case_underscore_style.required_prefix = _ +dotnet_naming_style.camel_case_underscore_style.capitalization = camel_case + +# Code style defaults +csharp_using_directive_placement = outside_namespace:suggestion +dotnet_sort_system_directives_first = true +csharp_prefer_braces = true:silent +csharp_preserve_single_line_blocks = true:none +csharp_preserve_single_line_statements = false:none +csharp_prefer_static_local_function = true:suggestion +csharp_prefer_simple_using_statement = false:none +csharp_style_prefer_switch_expression = true:suggestion + +# Code quality +dotnet_style_readonly_field = true:suggestion +dotnet_code_quality_unused_parameters = non_public:suggestion + +# Expression-level preferences +dotnet_style_object_initializer = true:suggestion +dotnet_style_collection_initializer = true:suggestion +dotnet_style_explicit_tuple_names = true:suggestion +dotnet_style_coalesce_expression = true:suggestion +dotnet_style_null_propagation = true:suggestion +dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion +dotnet_style_prefer_inferred_tuple_names = true:suggestion +dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion +dotnet_style_prefer_auto_properties = true:suggestion +dotnet_style_prefer_conditional_expression_over_assignment = true:silent +dotnet_style_prefer_conditional_expression_over_return = true:silent +csharp_prefer_simple_default_expression = true:suggestion + +# Expression-bodied members +csharp_style_expression_bodied_methods = true:silent +csharp_style_expression_bodied_constructors = true:silent +csharp_style_expression_bodied_operators = true:silent +csharp_style_expression_bodied_properties = true:silent +csharp_style_expression_bodied_indexers = true:silent +csharp_style_expression_bodied_accessors = true:silent +csharp_style_expression_bodied_lambdas = true:silent +csharp_style_expression_bodied_local_functions = true:silent + +# Pattern matching +csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion +csharp_style_pattern_matching_over_as_with_null_check = true:suggestion +csharp_style_inlined_variable_declaration = true:suggestion + +# Null checking preferences +csharp_style_throw_expression = true:suggestion +csharp_style_conditional_delegate_call = true:suggestion + +# Other features +csharp_style_prefer_index_operator = false:none +csharp_style_prefer_range_operator = false:none +csharp_style_pattern_local_over_anonymous_function = false:none + +# Space preferences +csharp_space_after_cast = false +csharp_space_after_colon_in_inheritance_clause = true +csharp_space_after_comma = true +csharp_space_after_dot = false +csharp_space_after_keywords_in_control_flow_statements = true +csharp_space_after_semicolon_in_for_statement = true +csharp_space_around_binary_operators = before_and_after +csharp_space_around_declaration_statements = do_not_ignore +csharp_space_before_colon_in_inheritance_clause = true +csharp_space_before_comma = false +csharp_space_before_dot = false +csharp_space_before_open_square_brackets = false +csharp_space_before_semicolon_in_for_statement = false +csharp_space_between_empty_square_brackets = false +csharp_space_between_method_call_empty_parameter_list_parentheses = false +csharp_space_between_method_call_name_and_opening_parenthesis = false +csharp_space_between_method_call_parameter_list_parentheses = false +csharp_space_between_method_declaration_empty_parameter_list_parentheses = false +csharp_space_between_method_declaration_name_and_open_parenthesis = false +csharp_space_between_method_declaration_parameter_list_parentheses = false +csharp_space_between_parentheses = false +csharp_space_between_square_brackets = false + +# Default analyzed API surface = 'all' (public APIs + non-public APIs) +dotnet_code_quality.api_surface = all + +# License header +file_header_template = /*\n * Licensed to the Apache Software Foundation (ASF) under one\n * or more contributor license agreements. See the NOTICE file\n * distributed with this work for additional information\n * regarding copyright ownership. The ASF licenses this file\n * to you under the Apache License, Version 2.0 (the\n * "License"); you may not use this file except in compliance\n * with the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing,\n * software distributed under the License is distributed on an\n * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n * KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations\n * under the License.\n */ + +# Code files +[*.{cs,vb}] +# Analyzers +dotnet_code_quality.ca1802.api_surface = private, internal +dotnet_code_quality.ca1822.api_surface = private, internal +dotnet_code_quality.ca2208.api_surface = public +# Mark attributes with AttributeUsageAttribute +dotnet_diagnostic.CA1018.severity = warning +# Properties should not be write only +dotnet_diagnostic.CA1044.severity = warning +# Do not declare protected member in sealed type +dotnet_diagnostic.CA1047.severity = warning +# Avoid using cref tags with a prefix +dotnet_diagnostic.CA1200.severity = suggestion +# P/Invokes should not be visible +dotnet_diagnostic.CA1401.severity = warning +# Parameter names should match base declaration +dotnet_diagnostic.CA1725.severity = suggestion +# Remove empty Finalizers +dotnet_diagnostic.CA1821.severity = warning +# Mark assemblies with NeutralResourcesLanguageAttribute +dotnet_diagnostic.CA1824.severity = warning +# Do not use CountAsync() or LongCountAsync() when AnyAsync() can be used +dotnet_diagnostic.CA1828.severity = warning +# Prefer strongly-typed Append and Insert method overloads on StringBuilder. +dotnet_diagnostic.CA1830.severity = warning +# Use AsSpan or AsMemory instead of Range-based indexers when appropriate +dotnet_diagnostic.CA1832.severity = warning +# Use AsSpan or AsMemory instead of Range-based indexers when appropriate +dotnet_diagnostic.CA1833.severity = warning +# Prefer IsEmpty over Count +dotnet_diagnostic.CA1836.severity = warning +# Use 'Environment.ProcessPath' +dotnet_diagnostic.CA1839.severity = warning +# Do not call ToImmutableCollection on an ImmutableCollection value +# Temporarily disable to avoid regression in preview 1, revert back to warning when start using preview 2 +dotnet_diagnostic.CA2009.severity = none +# Avoid infinite recursion +dotnet_diagnostic.CA2011.severity = warning +# Initialize value type static fields inline +dotnet_diagnostic.CA2207.severity = warning +# Implement serialization constructors +dotnet_diagnostic.CA2229.severity = warning +# Provide correct arguments to formatting methods +dotnet_diagnostic.CA2241.severity = warning +# Test for NaN correctly +dotnet_diagnostic.CA2242.severity = warning +# Do not assign a property to itself. +dotnet_diagnostic.CA2245.severity = warning +# Provide correct 'enum' argument to 'Enum.HasFlag' +dotnet_diagnostic.CA2248.severity = warning +# Do Not Add Schema By URL +dotnet_diagnostic.CA3061.severity = warning +# Insecure DTD processing in XML +dotnet_diagnostic.CA3075.severity = warning +# Insecure XSLT script processing. +dotnet_diagnostic.CA3076.severity = warning +# Insecure Processing in API Design, XmlDocument and XmlTextReader +dotnet_diagnostic.CA3077.severity = warning +# Mark Verb Handlers With Validate Antiforgery Token +dotnet_diagnostic.CA3147.severity = warning +# Do Not Use Broken Cryptographic Algorithms +dotnet_diagnostic.CA5351.severity = warning +# Do Not Disable Certificate Validation +dotnet_diagnostic.CA5359.severity = warning +# Do Not Call Dangerous Methods In Deserialization +dotnet_diagnostic.CA5360.severity = warning +# Do Not Disable SChannel Use of Strong Crypto +dotnet_diagnostic.CA5361.severity = warning +# Do Not Disable Request Validation +dotnet_diagnostic.CA5363.severity = warning +# Do Not Use Deprecated Security Protocols +dotnet_diagnostic.CA5364.severity = warning +# Do Not Disable HTTP Header Checking +dotnet_diagnostic.CA5365.severity = warning +# Set ViewStateUserKey For Classes Derived From Page +dotnet_diagnostic.CA5368.severity = warning +# Use XmlReader For Validating Reader +dotnet_diagnostic.CA5370.severity = warning +# Do not use obsolete key derivation function +dotnet_diagnostic.CA5373.severity = warning +# Do Not Use XslTransform +dotnet_diagnostic.CA5374.severity = warning +# Use SharedAccessProtocol HttpsOnly +dotnet_diagnostic.CA5376.severity = warning +# Use Container Level Access Policy +dotnet_diagnostic.CA5377.severity = warning +# Do not disable ServicePointManagerSecurityProtocols +dotnet_diagnostic.CA5378.severity = warning +# Do Not Use Weak Key Derivation Function Algorithm +dotnet_diagnostic.CA5379.severity = warning +# Do Not Add Certificates To Root Store +dotnet_diagnostic.CA5380.severity = warning +# Ensure Certificates Are Not Added To Root Store +dotnet_diagnostic.CA5381.severity = warning +# Do Not Use Digital Signature Algorithm (DSA) +dotnet_diagnostic.CA5384.severity = warning +# Use Rivest–Shamir–Adleman (RSA) Algorithm With Sufficient Key Size +dotnet_diagnostic.CA5385.severity = warning +dotnet_diagnostic.CS1591.severity = suggestion +# UseIsNullCheck +dotnet_diagnostic.IDE0041.severity = warning +# ValidateFormatString +dotnet_diagnostic.IDE0043.severity = warning +# MakeLocalFunctionStatic +dotnet_diagnostic.IDE0062.severity = warning +# ConvertTypeOfToNameOf +dotnet_diagnostic.IDE0082.severity = warning +# Remove unnecessary lambda expression +dotnet_diagnostic.IDE0200.severity = none +# Remove redundant nullable directive +dotnet_diagnostic.IDE0240.severity = warning + +# C++ Files +[*.{cpp,h,in}] +curly_bracket_next_line = true +indent_brace_style = Allman + +# Xml project files +[*.{csproj,vbproj,vcxproj,vcxproj.filters,proj,nativeproj,locproj}] +indent_size = 2 + +[*.{csproj,vbproj,proj,nativeproj,locproj}] +charset = utf-8-bom + +# Xml build files +[*.builds] +indent_size = 2 + +# Xml files +[*.{xml,stylecop,resx,ruleset}] +indent_size = 2 + +# Xml config files +[*.{props,targets,config,nuspec}] +indent_size = 2 + +# YAML config files +[*.{yml,yaml}] +indent_size = 2 + +# Shell scripts +[*.sh] +end_of_line = lf +[*.{cmd, bat}] +end_of_line = crlf + +# IDE0040: Add accessibility modifiers +dotnet_diagnostic.IDE0040.severity = warning + +[*.txt] +insert_final_newline = false + +# Verify settings +[*.{received,verified}.{txt,xml,json}] +charset = "utf-8-bom" +end_of_line = lf +indent_size = unset +indent_style = unset +insert_final_newline = false +tab_width = unset +trim_trailing_whitespace = false diff --git a/samples/Apache.IoTDB.Samples/Program.cs b/samples/Apache.IoTDB.Samples/Program.cs index b825063..3bdc715 100644 --- a/samples/Apache.IoTDB.Samples/Program.cs +++ b/samples/Apache.IoTDB.Samples/Program.cs @@ -17,12 +17,12 @@ * under the License. */ +using System; +using System.Collections.Generic; +using System.CommandLine; +using System.Threading.Tasks; using Microsoft.Extensions.Logging; using NLog.Extensions.Logging; -using System.Threading.Tasks; -using System.CommandLine; -using System.Collections.Generic; -using System; namespace Apache.IoTDB.Samples { diff --git a/samples/Apache.IoTDB.Samples/SessionPoolTest.cs b/samples/Apache.IoTDB.Samples/SessionPoolTest.cs index a189461..8b27c97 100644 --- a/samples/Apache.IoTDB.Samples/SessionPoolTest.cs +++ b/samples/Apache.IoTDB.Samples/SessionPoolTest.cs @@ -19,13 +19,13 @@ using System; using System.Collections.Generic; +using System.Diagnostics; +using System.Net.Sockets; using System.Threading; using System.Threading.Tasks; using Apache.IoTDB.Data; using Apache.IoTDB.DataStructure; using ConsoleTableExt; -using System.Net.Sockets; -using System.Diagnostics; namespace Apache.IoTDB.Samples { diff --git a/samples/Apache.IoTDB.Samples/TableSessionPoolTest.cs b/samples/Apache.IoTDB.Samples/TableSessionPoolTest.cs index 36d2b88..cebcd2f 100644 --- a/samples/Apache.IoTDB.Samples/TableSessionPoolTest.cs +++ b/samples/Apache.IoTDB.Samples/TableSessionPoolTest.cs @@ -39,7 +39,8 @@ public async Task Test() await TestSelectAndInsert(); await TestUseDatabase(); - // await TestCleanup(); + await TestInsertWithNull(); + await TestCleanup(); } @@ -161,6 +162,87 @@ public async Task TestUseDatabase() await tableSessionPool.Close(); } + public async Task TestInsertWithNull() + { + var tableName = "t1"; + + var tableSessionPool = new TableSessionPool.Builder() + .SetNodeUrls(sessionPoolTest.nodeUrls) + .SetUsername(sessionPoolTest.username) + .SetPassword(sessionPoolTest.password) + .SetFetchSize(1024) + .SetDatabase("test1") + .Build(); + + await tableSessionPool.Open(false); + + if (sessionPoolTest.debug) tableSessionPool.OpenDebugMode(); + + await tableSessionPool.ExecuteNonQueryStatementAsync( + "create table " + tableName + "(" + + "t1 STRING TAG," + + "f1 DATE FIELD)"); + + List columnNames = + new List { + "t1", + "f1" }; + List dataTypes = + new List{ + TSDataType.STRING, + TSDataType.DATE}; + List columnCategories = + new List{ + ColumnCategory.TAG, + ColumnCategory.FIELD}; + var timestamps = new List + { + 0L, + 1L, + 2L, + 3L, + 4L, + 5L, + 6L, + 7L, + 8L, + 9L + }; + var values = new List> { }; + values.Add(new List { "t1", DateTime.Parse("2024-08-15") }); + values.Add(new List { "t1", DateTime.Parse("2024-08-15") }); + values.Add(new List { "t1", DateTime.Parse("2024-08-15") }); + values.Add(new List { "t1", DateTime.Parse("2024-08-15") }); + values.Add(new List { "t1", DateTime.Parse("2024-08-15") }); + values.Add(new List { "t1", null }); + values.Add(new List { "t1", null }); + values.Add(new List { "t1", null }); + values.Add(new List { "t1", null }); + values.Add(new List { "t1", null }); + var tablet = new Tablet(tableName, columnNames, columnCategories, dataTypes, values, timestamps); + + await tableSessionPool.InsertAsync(tablet); + + + var res = await tableSessionPool.ExecuteQueryStatementAsync("select count(*) from " + tableName + " where f1 is null"); + while (res.HasNext()) + { + var row = res.Next(); + Console.WriteLine(row); + var value = row.Values[0]; + if (value is long longValue) + { + if (longValue != 5) + { + throw new Exception("Expected value is 5, but got " + longValue); + } + } + } + await res.Close(); + + await tableSessionPool.Close(); + } + public async Task TestCleanup() { var tableSessionPool = new TableSessionPool.Builder() diff --git a/src/Apache.IoTDB.Data/IoTDBCommand.cs b/src/Apache.IoTDB.Data/IoTDBCommand.cs index 8daf86a..f717a83 100644 --- a/src/Apache.IoTDB.Data/IoTDBCommand.cs +++ b/src/Apache.IoTDB.Data/IoTDBCommand.cs @@ -17,7 +17,6 @@ * under the License. */ -using Apache.IoTDB.DataStructure; using System; using System.Collections.Generic; using System.ComponentModel; @@ -30,6 +29,7 @@ using System.Runtime.InteropServices; using System.Threading; using System.Threading.Tasks; +using Apache.IoTDB.DataStructure; namespace Apache.IoTDB.Data diff --git a/src/Apache.IoTDB.Data/IoTDBConnection.cs b/src/Apache.IoTDB.Data/IoTDBConnection.cs index 96b3154..507a153 100644 --- a/src/Apache.IoTDB.Data/IoTDBConnection.cs +++ b/src/Apache.IoTDB.Data/IoTDBConnection.cs @@ -23,14 +23,13 @@ using System.Data.Common; using System.Diagnostics; using System.IO; +using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Text; - -using System.Linq; -using System.Threading.Tasks; using System.Threading; +using System.Threading.Tasks; namespace Apache.IoTDB.Data { diff --git a/src/Apache.IoTDB.Data/IoTDBDataReader.cs b/src/Apache.IoTDB.Data/IoTDBDataReader.cs index da4f107..156844e 100644 --- a/src/Apache.IoTDB.Data/IoTDBDataReader.cs +++ b/src/Apache.IoTDB.Data/IoTDBDataReader.cs @@ -17,7 +17,6 @@ * under the License. */ -using Apache.IoTDB.DataStructure; using System; using System.Collections; using System.Collections.Generic; @@ -27,6 +26,7 @@ using System.Linq; using System.Runtime.InteropServices; using System.Text; +using Apache.IoTDB.DataStructure; namespace Apache.IoTDB.Data @@ -525,7 +525,7 @@ public override DataTable GetSchemaTable() var tableName1 = string.Empty; schemaRow1[BaseTableName] = tableName1; schemaRow1[DataType] = typeof(DateTime); - schemaRow1[DataTypeName] = typeof(DateTime).Name; + schemaRow1[DataTypeName] = nameof(DateTime); schemaRow1[IsExpression] = columnName1 == null; schemaRow1[IsLong] = DBNull.Value; schemaRow1[IsKey] = true; diff --git a/src/Apache.IoTDB/DataStructure/BitMap.cs b/src/Apache.IoTDB/DataStructure/BitMap.cs index 5a1b607..75b2d58 100644 --- a/src/Apache.IoTDB/DataStructure/BitMap.cs +++ b/src/Apache.IoTDB/DataStructure/BitMap.cs @@ -23,7 +23,7 @@ #endif public class BitMap { - private static byte[] BIT_UTIL = new byte[] { 1, 2, 4, 8, 16, 32, 64, 255 }; + private static byte[] BIT_UTIL = new byte[] { 1, 2, 4, 8, 16, 32, 64, unchecked((byte)-128) }; private static byte[] UNMARK_BIT_UTIL = new byte[] { (byte) 0XFE, // 11111110 @@ -94,7 +94,7 @@ public void mark(int position) public void reset() { #if NET461_OR_GREATER || NETSTANDARD2_0 - bits.Fill((byte)0xFF); + bits.Fill((byte)0); #else Array.Fill(bits, (byte)0); #endif diff --git a/src/Apache.IoTDB/DataStructure/Tablet.cs b/src/Apache.IoTDB/DataStructure/Tablet.cs index 34007ee..471bff5 100644 --- a/src/Apache.IoTDB/DataStructure/Tablet.cs +++ b/src/Apache.IoTDB/DataStructure/Tablet.cs @@ -44,6 +44,8 @@ namespace Apache.IoTDB.DataStructure */ public class Tablet { + + private static int EMPTY_DATE_INT = 10000101; private readonly List _timestamps; private readonly List> _values; @@ -368,85 +370,85 @@ public byte[] GetBinaryValues() switch (dataType) { case TSDataType.BOOLEAN: + { + for (int j = 0; j < RowNumber; j++) { - for (int j = 0; j < RowNumber; j++) - { - var value = _values[j][i]; - buffer.AddBool(value != null ? (bool)value : false); - } - - break; + var value = _values[j][i]; + buffer.AddBool(value != null ? (bool)value : false); } + + break; + } case TSDataType.INT32: + { + for (int j = 0; j < RowNumber; j++) { - for (int j = 0; j < RowNumber; j++) - { - var value = _values[j][i]; - buffer.AddInt(value != null ? (int)value : int.MinValue); - } - - break; + var value = _values[j][i]; + buffer.AddInt(value != null ? (int)value : int.MinValue); } + + break; + } case TSDataType.INT64: case TSDataType.TIMESTAMP: + { + for (int j = 0; j < RowNumber; j++) { - for (int j = 0; j < RowNumber; j++) - { - var value = _values[j][i]; - buffer.AddLong(value != null ? (long)value : long.MinValue); - } - - break; + var value = _values[j][i]; + buffer.AddLong(value != null ? (long)value : long.MinValue); } + + break; + } case TSDataType.FLOAT: + { + for (int j = 0; j < RowNumber; j++) { - for (int j = 0; j < RowNumber; j++) - { - var value = _values[j][i]; - buffer.AddFloat(value != null ? (float)value : float.MinValue); - } - - break; + var value = _values[j][i]; + buffer.AddFloat(value != null ? (float)value : float.MinValue); } + + break; + } case TSDataType.DOUBLE: + { + for (int j = 0; j < RowNumber; j++) { - for (int j = 0; j < RowNumber; j++) - { - var value = _values[j][i]; - buffer.AddDouble(value != null ? (double)value : double.MinValue); - } - - break; + var value = _values[j][i]; + buffer.AddDouble(value != null ? (double)value : double.MinValue); } + + break; + } case TSDataType.TEXT: case TSDataType.STRING: + { + for (int j = 0; j < RowNumber; j++) { - for (int j = 0; j < RowNumber; j++) - { - var value = _values[j][i]; - buffer.AddStr(value != null ? (string)value : string.Empty); - } - - break; + var value = _values[j][i]; + buffer.AddStr(value != null ? (string)value : string.Empty); } + + break; + } case TSDataType.DATE: + { + for (int j = 0; j < RowNumber; j++) { - for (int j = 0; j < RowNumber; j++) - { - var value = _values[j][i]; - buffer.AddInt(value != null ? Utils.ParseDateToInt((DateTime)value) : int.MinValue); - } - break; + var value = _values[j][i]; + buffer.AddInt(value != null ? Utils.ParseDateToInt((DateTime)value) : EMPTY_DATE_INT); } + break; + } case TSDataType.BLOB: + { + for (int j = 0; j < RowNumber; j++) { - for (int j = 0; j < RowNumber; j++) - { - var value = _values[j][i]; - buffer.AddBinary(value != null ? (byte[])value : new byte[] { }); - } - break; + var value = _values[j][i]; + buffer.AddBinary(value != null ? (byte[])value : new byte[] { }); } + break; + } default: throw new Exception($"Unsupported data type {dataType}", null); }