feat(client): add Long256 support (#7)

* add: Long256Column() function

The support for long type has been addded. The implementation is done, but it doesn't seem to be working as expected.

* implemented long256Colums() using string as parameter

The string method is a temporary fix, it supports data entry in long256 until 64bit. After that it thows an error. Examine it in examples/long/long.go

* feat: support for long256 added

func Long256Column() added along with unit test.

* add: Integration test for long256

* typos: fixed minor typos and added suggestions

* fix: expanded defination

Author: jammutkarsh

sender.go

@@ -323,6 +323,33 @@ func (s *LineSender) Int64Column(name string, val int64) *LineSender {
 	return s
 }
 
+// Long256Column adds a 256-bit unsigned integer (long256) column
+// value to the ILP message.
+// 
+// val should contain a hex encoded 256-bit unsigned integer value
+// with "0x" prefix and "i" suffix. Any attempt to set a string which is
+// not a hexadecimal will not be parsed and rejected by the database.
+// 
+// Column name cannot contain any of the following characters:
+// '\n', '\r', '?', '.', ',', ”', '"', '\\', '/', ':', ')', '(', '+',
+// '-', '*' '%%', '~', or a non-printable char.
+func (s *LineSender) Long256Column(name, val string) *LineSender {
+	if !s.prepareForField(name) {
+		return s
+	}
+	s.lastErr = s.writeColumnName(name)
+	if s.lastErr != nil {
+		return s
+	}
+	s.buf.WriteByte('=')
+	s.lastErr = s.writeStrValue(val, false)
+	if s.lastErr != nil {
+		return s
+	}
+	s.hasFields = true
+	return s
+}
+
 // TimestampColumn adds a timestamp column value to the ILP
 // message. Timestamp is Epoch microseconds.
 //

sender_integration_test.go

@@ -236,6 +236,7 @@ func TestE2EValidWrites(t *testing.T) {
 					Symbol("sym_col", "test_ilp1").
 					Float64Column("double_col", 12.2).
 					Int64Column("long_col", 12).
+					Long256Column("long256_col", "0x123a4i").
 					StringColumn("str_col", "foobar").
 					BoolColumn("bool_col", true).
 					TimestampColumn("timestamp_col", 42).
@@ -249,6 +250,7 @@ func TestE2EValidWrites(t *testing.T) {
 					Symbol("sym_col", "test_ilp2").
 					Float64Column("double_col", 11.2).
 					Int64Column("long_col", 11).
+					Long256Column("long256_col", "0x123a3i").
 					StringColumn("str_col", "barbaz").
 					BoolColumn("bool_col", false).
 					TimestampColumn("timestamp_col", 43).
@@ -259,14 +261,15 @@ func TestE2EValidWrites(t *testing.T) {
 					{"sym_col", "SYMBOL"},
 					{"double_col", "DOUBLE"},
 					{"long_col", "LONG"},
+					{"long256_col", "LONG256"},
 					{"str_col", "STRING"},
 					{"bool_col", "BOOLEAN"},
 					{"timestamp_col", "TIMESTAMP"},
 					{"timestamp", "TIMESTAMP"},
 				},
 				Dataset: [][]interface{}{
-					{"test_ilp1", float64(12.2), float64(12), "foobar", true, "1970-01-01T00:00:00.000042Z", "1970-01-01T00:00:00.000001Z"},
-					{"test_ilp2", float64(11.2), float64(11), "barbaz", false, "1970-01-01T00:00:00.000043Z", "1970-01-01T00:00:00.000002Z"},
+					{"test_ilp1", float64(12.2), float64(12), "0x0123a4", "foobar", true, "1970-01-01T00:00:00.000042Z", "1970-01-01T00:00:00.000001Z"},
+					{"test_ilp2", float64(11.2), float64(11), "0x0123a3", "barbaz", false, "1970-01-01T00:00:00.000043Z", "1970-01-01T00:00:00.000002Z"},
 				},
 				Count: 2,
 			},
@@ -333,6 +336,26 @@ func TestE2EValidWrites(t *testing.T) {
 				Count: 1,
 			},
 		},
+		{
+			"single column long256",
+			testTable,
+			func(s *qdb.LineSender) error {
+				return s.
+					Table(testTable).
+					Long256Column("foobar", "0x123a4i").
+					At(ctx, 42000)
+			},
+			tableData{
+				Columns: []column{
+					{"foobar", "LONG256"},
+					{"timestamp", "TIMESTAMP"},
+				},
+				Dataset: [][]interface{}{
+					{"0x0123a4", "1970-01-01T00:00:00.000042Z"},
+				},
+				Count: 1,
+			},
+		},
 		{
 			"double value with exponent",
 			testTable,

sender_test.go

@@ -184,6 +184,45 @@ func TestInt64Serialization(t *testing.T) {
 	}
 }
 
+func TestLong256Column(t *testing.T) {
+	ctx := context.Background()
+
+	testCases := []struct {
+		name     string
+		val      string
+		expected string
+	}{
+		{"random bits ", "0x0123a4i", "0x0123a4"},
+		{"8bit max", "0xffffffffi", "0xffffffff"},
+		{"16bit max", "0xffffffffffffffffi", "0xffffffffffffffff"},
+		{"32bit max", "0xffffffffffffffffffffffffffffffffi", "0xffffffffffffffffffffffffffffffff"},
+		{"64bit long", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffi", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			srv, err := newTestServer(sendToBackChannel)
+			assert.NoError(t, err)
+
+			sender, err := qdb.NewLineSender(ctx, qdb.WithAddress(srv.addr))
+			assert.NoError(t, err)
+
+			err = sender.Table(testTable).Long256Column("a_col", tc.val).AtNow(ctx)
+			assert.NoError(t, err)
+
+			err = sender.Flush(ctx)
+			assert.NoError(t, err)
+
+			sender.Close()
+
+			// Now check what was received by the server.
+			expectLines(t, srv.backCh, []string{"my_test_table a_col=" + tc.expected + "i"})
+
+			srv.close()
+		})
+	}
+}
+
 func TestFloat64Serialization(t *testing.T) {
 	ctx := context.Background()