Remove symbol usage where needed.

all_examples_helper_test.go

@@ -19,7 +19,7 @@ func MustCreateTimeseriesWithColumns(alias string) (*HandleType, *TimeseriesEntr
 
 func MustCreateTimeseriesWithData(alias string) (*HandleType, *TimeseriesEntry) {
 	h, timeseries := MustCreateTimeseriesWithColumns(alias)
-	blobColumns, doubleColumns, int64Columns, stringColumns, timestampColumns, symbolColumns, err := timeseries.Columns()
+	blobColumns, doubleColumns, int64Columns, stringColumns, timestampColumns, err := timeseries.Columns()
 	if err != nil {
 		panic(err)
 	}
@@ -31,15 +31,13 @@ func MustCreateTimeseriesWithData(alias string) (*HandleType, *TimeseriesEntry)
 	int64Points := make([]TsInt64Point, count)
 	stringPoints := make([]TsStringPoint, count)
 	timestampPoints := make([]TsTimestampPoint, count)
-	symbolPoints := make([]TsSymbolPoint, count)
 	for idx := int64(0); idx < count; idx++ {
 		timestamps[idx] = time.Unix((idx+1)*10, 0)
 		blobPoints[idx] = NewTsBlobPoint(timestamps[idx], []byte(fmt.Sprintf("content_%d", idx)))
 		doublePoints[idx] = NewTsDoublePoint(timestamps[idx], float64(idx))
 		int64Points[idx] = NewTsInt64Point(timestamps[idx], idx)
 		stringPoints[idx] = NewTsStringPoint(timestamps[idx], fmt.Sprintf("content_%d", idx))
 		timestampPoints[idx] = NewTsTimestampPoint(timestamps[idx], timestamps[idx])
-		symbolPoints[idx] = NewTsSymbolPoint(timestamps[idx], fmt.Sprintf("content_%d", idx))
 	}
 	err = blobColumns[0].Insert(blobPoints...)
 	if err != nil {
@@ -61,7 +59,7 @@ func MustCreateTimeseriesWithData(alias string) (*HandleType, *TimeseriesEntry)
 	if err != nil {
 		panic(err)
 	}
-	err = symbolColumns[0].Insert(symbolPoints...)
+	err = stringColumns[1].Insert(stringPoints...)
 	if err != nil {
 		panic(err)
 	}

all_examples_test.go

@@ -138,7 +138,7 @@ func ExampleTimeseriesEntry_Columns() {
 	defer h.Close()
 	SetLogFile("qdb_api.examples.log")
 
-	blobColumns, doubleColumns, int64Columns, stringColumns, timestampColumns, symbolColumns, err := timeseries.Columns()
+	blobColumns, doubleColumns, int64Columns, stringColumns, timestampColumns, err := timeseries.Columns()
 	if err != nil {
 		// handle error
 	}
@@ -162,17 +162,13 @@ func ExampleTimeseriesEntry_Columns() {
 		fmt.Println("column:", col.Name())
 		// do something like Insert, GetRanges with a timestamp column
 	}
-	for _, col := range symbolColumns {
-		fmt.Println("column:", col.Name())
-		// do something like Insert, GetRanges with a symbol column
-	}
 	// Output:
 	// column: series_column_blob
 	// column: series_column_double
 	// column: series_column_int64
 	// column: series_column_string
-	// column: series_column_timestamp
 	// column: series_column_symbol
+	// column: series_column_timestamp
 }
 
 func ExampleTimeseriesEntry_ColumnsInfo() {

entry_timeseries_blob_test.go

@@ -57,13 +57,13 @@ var _ = Describe("Tests", func() {
 			timeseries.Remove()
 		})
 		It("should have one blob column", func() {
-			cols, _, _, _, _, _, err := timeseries.Columns()
+			cols, _, _, _, _, err := timeseries.Columns()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(1).To(Equal(len(cols)))
 			Expect(TsColumnBlob).To(Equal(cols[0].Type()))
 		})
 		It("should retrieve one blob column", func() {
-			cols, _, _, _, _, _, err := timeseries.Columns()
+			cols, _, _, _, _, err := timeseries.Columns()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(1).To(Equal(len(cols)))
 			Expect(column.Type()).To(Equal(cols[0].Type()))

entry_timeseries_common.go

@@ -149,14 +149,13 @@ func oldColumnInfoArrayToSlice(columns *C.qdb_ts_column_info_t, length int) []C.
 	return (*[(math.MaxInt32 - 1) / unsafe.Sizeof(C.qdb_ts_column_info_t{})]C.qdb_ts_column_info_t)(unsafe.Pointer(columns))[:length:length]
 }
 
-func columnArrayToGo(entry TimeseriesEntry, columns *C.qdb_ts_column_info_ex_t, columnsCount C.qdb_size_t) ([]TsBlobColumn, []TsDoubleColumn, []TsInt64Column, []TsStringColumn, []TsTimestampColumn, []TsSymbolColumn) {
+func columnArrayToGo(entry TimeseriesEntry, columns *C.qdb_ts_column_info_ex_t, columnsCount C.qdb_size_t) ([]TsBlobColumn, []TsDoubleColumn, []TsInt64Column, []TsStringColumn, []TsTimestampColumn) {
 	length := int(columnsCount)
 	blobColumns := []TsBlobColumn{}
 	doubleColumns := []TsDoubleColumn{}
 	int64Columns := []TsInt64Column{}
 	stringColumns := []TsStringColumn{}
 	timestampColumns := []TsTimestampColumn{}
-	symbolColumns := []TsSymbolColumn{}
 	if length > 0 {
 		slice := columnInfoArrayToSlice(columns, length)
 		for _, s := range slice {
@@ -166,20 +165,18 @@ func columnArrayToGo(entry TimeseriesEntry, columns *C.qdb_ts_column_info_ex_t,
 				doubleColumns = append(doubleColumns, TsDoubleColumn{s.toStructG(entry)})
 			} else if s._type == C.qdb_ts_column_int64 {
 				int64Columns = append(int64Columns, TsInt64Column{s.toStructG(entry)})
-			} else if s._type == C.qdb_ts_column_string {
+			} else if s._type == C.qdb_ts_column_string || s._type == C.qdb_ts_column_symbol {
 				stringColumns = append(stringColumns, TsStringColumn{s.toStructG(entry)})
 			} else if s._type == C.qdb_ts_column_timestamp {
 				timestampColumns = append(timestampColumns, TsTimestampColumn{s.toStructG(entry)})
-			} else if s._type == C.qdb_ts_column_symbol {
-				symbolColumns = append(symbolColumns, TsSymbolColumn{s.toStructG(entry)})
 			}
 		}
 	}
-	return blobColumns, doubleColumns, int64Columns, stringColumns, timestampColumns, symbolColumns
+	return blobColumns, doubleColumns, int64Columns, stringColumns, timestampColumns
 }
 
 // Columns : return the current columns
-func (entry TimeseriesEntry) Columns() ([]TsBlobColumn, []TsDoubleColumn, []TsInt64Column, []TsStringColumn, []TsTimestampColumn, []TsSymbolColumn, error) {
+func (entry TimeseriesEntry) Columns() ([]TsBlobColumn, []TsDoubleColumn, []TsInt64Column, []TsStringColumn, []TsTimestampColumn, error) {
 	alias := convertToCharStar(entry.alias)
 	defer releaseCharStar(alias)
 	var columns *C.qdb_ts_column_info_ex_t
@@ -190,11 +187,10 @@ func (entry TimeseriesEntry) Columns() ([]TsBlobColumn, []TsDoubleColumn, []TsIn
 	var int64Columns []TsInt64Column
 	var stringColumns []TsStringColumn
 	var timestampColumns []TsTimestampColumn
-	var symbolColumns []TsSymbolColumn
 	if err == 0 {
-		blobColumns, doubleColumns, int64Columns, stringColumns, timestampColumns, symbolColumns = columnArrayToGo(entry, columns, columnsCount)
+		blobColumns, doubleColumns, int64Columns, stringColumns, timestampColumns = columnArrayToGo(entry, columns, columnsCount)
 	}
-	return blobColumns, doubleColumns, int64Columns, stringColumns, timestampColumns, symbolColumns, makeErrorOrNil(err)
+	return blobColumns, doubleColumns, int64Columns, stringColumns, timestampColumns, makeErrorOrNil(err)
 }
 
 // ColumnsInfo : return the current columns information

entry_timeseries_common_test.go

@@ -27,7 +27,7 @@ var _ = Describe("Tests", func() {
 			int64Column     TsInt64Column
 			stringColumn    TsStringColumn
 			timestampColumn TsTimestampColumn
-			symbolColumn    TsSymbolColumn
+			symbolColumn    TsStringColumn
 			columnsInfo     []TsColumnInfo
 		)
 		const (
@@ -70,20 +70,19 @@ var _ = Describe("Tests", func() {
 				Expect(err).ToNot(HaveOccurred())
 			})
 			It("should not work to get columns before creating the time series", func() {
-				_, _, _, _, _, _, err := timeseries.Columns()
+				_, _, _, _, _, err := timeseries.Columns()
 				Expect(err).To(HaveOccurred())
 			})
 			It("should work with zero columns", func() {
 				err := timeseries.Create(24*time.Hour, columnsInfo...)
 				Expect(err).ToNot(HaveOccurred())
-				blobCols, doubleCols, int64Cols, stringCols, timestampCols, symbolCols, err := timeseries.Columns()
+				blobCols, doubleCols, int64Cols, stringCols, timestampCols, err := timeseries.Columns()
 				Expect(err).ToNot(HaveOccurred())
 				Expect(0).To(Equal(len(blobCols)))
 				Expect(0).To(Equal(len(doubleCols)))
 				Expect(0).To(Equal(len(int64Cols)))
 				Expect(0).To(Equal(len(stringCols)))
 				Expect(0).To(Equal(len(timestampCols)))
-				Expect(0).To(Equal(len(symbolCols)))
 			})
 			It("should work with a shard size of 1ms", func() {
 				err := timeseries.Create(1*time.Millisecond, columnsInfo...)
@@ -102,7 +101,6 @@ var _ = Describe("Tests", func() {
 				int64Points     []TsInt64Point
 				stringPoints    []TsStringPoint
 				timestampPoints []TsTimestampPoint
-				symbolPoints    []TsSymbolPoint
 			)
 			BeforeEach(func() {
 				timestamps = make([]time.Time, count)
@@ -111,15 +109,13 @@ var _ = Describe("Tests", func() {
 				int64Points = make([]TsInt64Point, count)
 				stringPoints = make([]TsStringPoint, count)
 				timestampPoints = make([]TsTimestampPoint, count)
-				symbolPoints = make([]TsSymbolPoint, count)
 				for idx := int64(0); idx < count; idx++ {
 					timestamps[idx] = time.Unix((idx+1)*10, 0)
 					blobPoints[idx] = NewTsBlobPoint(timestamps[idx], []byte(fmt.Sprintf("content_%d", idx)))
 					doublePoints[idx] = NewTsDoublePoint(timestamps[idx], float64(idx))
 					int64Points[idx] = NewTsInt64Point(timestamps[idx], idx)
 					stringPoints[idx] = NewTsStringPoint(timestamps[idx], fmt.Sprintf("content_%d", idx))
 					timestampPoints[idx] = NewTsTimestampPoint(timestamps[idx], timestamps[idx])
-					symbolPoints[idx] = NewTsSymbolPoint(timestamps[idx], fmt.Sprintf("content_%d", idx))
 				}
 			})
 			JustBeforeEach(func() {
@@ -133,20 +129,19 @@ var _ = Describe("Tests", func() {
 				symbolColumn = timeseries.SymbolColumn(columnsInfo[symbolIndex].Name(), symtableName)
 			})
 			It("should have one column of each type", func() {
-				blobCols, doubleCols, int64Cols, stringCols, timestampCols, symbolCols, err := timeseries.Columns()
+				blobCols, doubleCols, int64Cols, stringCols, timestampCols, err := timeseries.Columns()
 				Expect(err).ToNot(HaveOccurred())
 				Expect(1).To(Equal(len(doubleCols)))
 				Expect(1).To(Equal(len(blobCols)))
 				Expect(1).To(Equal(len(int64Cols)))
-				Expect(1).To(Equal(len(stringCols)))
+				Expect(2).To(Equal(len(stringCols)))
 				Expect(1).To(Equal(len(timestampCols)))
-				Expect(1).To(Equal(len(symbolCols)))
 				Expect(TsColumnDouble).To(Equal(doubleCols[0].Type()))
 				Expect(TsColumnBlob).To(Equal(blobCols[0].Type()))
 				Expect(TsColumnInt64).To(Equal(int64Cols[0].Type()))
 				Expect(TsColumnString).To(Equal(stringCols[0].Type()))
 				Expect(TsColumnTimestamp).To(Equal(timestampCols[0].Type()))
-				Expect(TsColumnSymbol).To(Equal(symbolCols[0].Type()))
+				Expect(TsColumnSymbol).To(Equal(stringCols[1].Type()))
 			})
 			Context("Insert Columns", func() {
 				It("should work to insert new columns", func() {
@@ -190,7 +185,7 @@ var _ = Describe("Tests", func() {
 						bulk, err := timeseries.Bulk()
 						Expect(err).ToNot(HaveOccurred())
 						for i := int64(0); i < count; i++ {
-							err := bulk.Row(time.Now()).Blob(blobValue).Double(doubleValue).Int64(int64Value).String(stringValue).Timestamp(timestampValue).Symbol(symbolValue).Append()
+							err := bulk.Row(time.Now()).Blob(blobValue).Double(doubleValue).Int64(int64Value).String(stringValue).Timestamp(timestampValue).String(symbolValue).Append()
 							Expect(err).ToNot(HaveOccurred())
 						}
 						_, err = bulk.Push()
@@ -201,7 +196,7 @@ var _ = Describe("Tests", func() {
 						bulk, err := timeseries.Bulk(columnsInfo...)
 						Expect(err).ToNot(HaveOccurred())
 						for i := int64(0); i < count; i++ {
-							err := bulk.Row(time.Now()).Blob(blobValue).Double(doubleValue).Int64(int64Value).String(stringValue).Timestamp(timestampValue).Symbol(symbolValue).Append()
+							err := bulk.Row(time.Now()).Blob(blobValue).Double(doubleValue).Int64(int64Value).String(stringValue).Timestamp(timestampValue).String(symbolValue).Append()
 							Expect(err).ToNot(HaveOccurred())
 						}
 						_, err = bulk.Push()
@@ -263,7 +258,7 @@ var _ = Describe("Tests", func() {
 						int64Column.Insert(int64Points...)
 						stringColumn.Insert(stringPoints...)
 						timestampColumn.Insert(timestampPoints...)
-						symbolColumn.Insert(symbolPoints...)
+						symbolColumn.Insert(stringPoints...)
 					})
 					It("Should work to get all values", func() {
 						bulk, err := timeseries.Bulk()
@@ -298,9 +293,9 @@ var _ = Describe("Tests", func() {
 							Expect(err).ToNot(HaveOccurred())
 							Expect(timestampPoints[bulk.RowCount()].Content()).To(Equal(timestampValue))
 
-							symbolValue, err := bulk.GetSymbol()
+							symbolValue, err := bulk.GetString()
 							Expect(err).ToNot(HaveOccurred())
-							Expect(symbolPoints[bulk.RowCount()].Content()).To(Equal(symbolValue))
+							Expect(stringPoints[bulk.RowCount()].Content()).To(Equal(symbolValue))
 						}
 						Expect(err).To(Equal(ErrIteratorEnd))
 						bulk.Release()
@@ -385,7 +380,7 @@ var _ = Describe("Tests", func() {
 							Expect(err).ToNot(HaveOccurred())
 							err = tsBatch.RowSetTimestamp(timestampIndex, timestampValue)
 							Expect(err).ToNot(HaveOccurred())
-							err = tsBatch.RowSetSymbol(symbolIndex, symbolValue)
+							err = tsBatch.RowSetString(symbolIndex, symbolValue)
 							Expect(err).ToNot(HaveOccurred())
 						})
 						It("should append columns and ignore fields", func() {
@@ -424,7 +419,7 @@ var _ = Describe("Tests", func() {
 								Expect(err).ToNot(HaveOccurred())
 								err = tsBatch.RowSetTimestamp(timestampIndex, timestampValue)
 								Expect(err).ToNot(HaveOccurred())
-								err = tsBatch.RowSetSymbol(symbolIndex, symbolValue)
+								err = tsBatch.RowSetString(symbolIndex, symbolValue)
 								Expect(err).ToNot(HaveOccurred())
 							})
 							It("should push", func() {
@@ -479,7 +474,7 @@ var _ = Describe("Tests", func() {
 								Expect(err).ToNot(HaveOccurred())
 								err = tsBatch.RowSetTimestamp(timestampIndex, timestampValue)
 								Expect(err).ToNot(HaveOccurred())
-								err = tsBatch.RowSetSymbol(symbolIndex, symbolValue)
+								err = tsBatch.RowSetString(symbolIndex, symbolValue)
 								Expect(err).ToNot(HaveOccurred())
 							})
 							It("should push", func() {

entry_timeseries_double_test.go

@@ -56,13 +56,13 @@ var _ = Describe("Tests", func() {
 			timeseries.Remove()
 		})
 		It("should have one double column", func() {
-			_, cols, _, _, _, _, err := timeseries.Columns()
+			_, cols, _, _, _, err := timeseries.Columns()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(1).To(Equal(len(cols)))
 			Expect(TsColumnDouble).To(Equal(cols[0].Type()))
 		})
 		It("should retrieve one double column", func() {
-			_, cols, _, _, _, _, err := timeseries.Columns()
+			_, cols, _, _, _, err := timeseries.Columns()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(1).To(Equal(len(cols)))
 			Expect(column.Type()).To(Equal(cols[0].Type()))

entry_timeseries_int64_test.go

@@ -56,13 +56,13 @@ var _ = Describe("Tests", func() {
 			timeseries.Remove()
 		})
 		It("should have one int64 column", func() {
-			_, _, cols, _, _, _, err := timeseries.Columns()
+			_, _, cols, _, _, err := timeseries.Columns()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(1).To(Equal(len(cols)))
 			Expect(TsColumnInt64).To(Equal(cols[0].Type()))
 		})
 		It("should retrieve one int64 column", func() {
-			_, _, cols, _, _, _, err := timeseries.Columns()
+			_, _, cols, _, _, err := timeseries.Columns()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(1).To(Equal(len(cols)))
 			Expect(column.Type()).To(Equal(cols[0].Type()))

entry_timeseries_string.go

@@ -90,6 +90,11 @@ func (entry TimeseriesEntry) StringColumn(columnName string) TsStringColumn {
 	return TsStringColumn{tsColumn{NewTsColumnInfo(columnName, TsColumnString), entry}}
 }
 
+// SymbolColumn : create a column object (the symbol table name is not set)
+func (entry TimeseriesEntry) SymbolColumn(columnName string, symtableName string) TsStringColumn {
+	return TsStringColumn{tsColumn{NewSymbolColumnInfo(columnName, symtableName), entry}}
+}
+
 // Insert string points into a timeseries
 func (column TsStringColumn) Insert(points ...TsStringPoint) error {
 	alias := convertToCharStar(column.parent.alias)

entry_timeseries_string_test.go

@@ -57,13 +57,13 @@ var _ = Describe("Tests", func() {
 			timeseries.Remove()
 		})
 		It("should have one string column", func() {
-			_, _, _, cols, _, _, err := timeseries.Columns()
+			_, _, _, cols, _, err := timeseries.Columns()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(1).To(Equal(len(cols)))
 			Expect(TsColumnString).To(Equal(cols[0].Type()))
 		})
 		It("should retrieve one string column", func() {
-			_, _, _, cols, _, _, err := timeseries.Columns()
+			_, _, _, cols, _, err := timeseries.Columns()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(1).To(Equal(len(cols)))
 			Expect(column.Type()).To(Equal(cols[0].Type()))