History

TimeSeriesPlatformLibrary: Completed computed column operation for DataColumns.

J. Ritchie Carroll committed 7 years ago

Commit 2bf78d31 parent f0515fd4 files · +437 −123Browse files

Showing the changes to Source/Libraries/TimeSeriesPlatformLibrary/Data/DataRow.cpp (1 of 4 files). Show all

Unified · Split

Source/Libraries/TimeSeriesPlatformLibrary/Data/DataRow.cpp+371−69
@@ -84,16 +84,16 @@ DataColumnPtr DataRow::ValidateColumnType(int32_t columnIndex, DataType targetTy · 83 unmodified lines
8484 return column;
8585 }
8686
87−ValueExpressionPtr DataRow::EvaluateExpression(const DataColumnPtr& column)
87+ExpressionTreePtr DataRow::GetExpressionTree(const DataColumnPtr& column)
8888 {
8989 const int columnIndex = column->Index();
9090
9191 FilterExpressionParser* parser = static_cast<FilterExpressionParser*>(m_values[columnIndex]);
9292
9393 if (parser)
94− return parser->GetExpressionTrees()[0]->Evaluate(shared_from_this());
94+ return parser->GetExpressionTrees()[0];
9595
96− const DataTablePtr dataTable = column->Parent();
96+ const DataTablePtr& dataTable = column->Parent();
9797 parser = new FilterExpressionParser(column->Expression());
9898
9999 parser->SetDataSet(dataTable->Parent());
@@ -111,54 +111,344 @@ ValueExpressionPtr DataRow::EvaluateExpression(const DataColumnPtr& column) · 11 unmodified lines
111111
112112 m_values[columnIndex] = parser;
113113
114− return expressionTrees[0]->Evaluate(shared_from_this());
114+ return expressionTrees[0];
115115 }
116116
117−template<typename T>
118−T DataRow::GetComputedValue(const DataColumnPtr& column, DataType targetType) const
117+Object DataRow::GetComputedValue(const DataColumnPtr& column, DataType targetType)
119118 {
120119 try
121120 {
122− //const ValueExpressionPtr computedValue = EvaluateExpression(column);
123−
124− // TODO: Evaluate value for type T
125− //switch (computedValue->ValueType)
126− //{
127− // case ExpressionValueType::Boolean:
128− // break;
129− // case ExpressionValueType::Int32:
130− // break;
131− // case ExpressionValueType::Int64:
132− // break;
133− // case ExpressionValueType::Decimal:
134− // break;
135− // case ExpressionValueType::Double:
136− // break;
137− // case ExpressionValueType::String:
138− // break;
139− // case ExpressionValueType::Guid:
140− // break;
141− // case ExpressionValueType::DateTime:
142− // break;
143− // default:
144− // throw ExpressionTreeException("Unexpected expression value type encountered");
145− //}
121+ const ExpressionTreePtr& expressionTree = GetExpressionTree(column);
122+ const ValueExpressionPtr& sourceValue = expressionTree->Evaluate(shared_from_this());
123+
124+ switch (sourceValue->ValueType)
125+ {
126+ case ExpressionValueType::Boolean:
127+ {
128+ const bool result = sourceValue->ValueAsBoolean();
129+ const int32_t value = result ? 1 : 0;
130+
131+ switch (targetType)
132+ {
133+ case DataType::String:
134+ return sourceValue->ToString();
135+ case DataType::Boolean:
136+ return result;
137+ case DataType::Single:
138+ return static_cast<float32_t>(value);
139+ case DataType::Double:
140+ return static_cast<float64_t>(value);
141+ case DataType::Decimal:
142+ return static_cast<decimal_t>(value);
143+ case DataType::Int8:
144+ return static_cast<int8_t>(value);
145+ case DataType::Int16:
146+ return static_cast<int16_t>(value);
147+ case DataType::Int32:
148+ return static_cast<int32_t>(value);
149+ case DataType::Int64:
150+ return static_cast<int64_t>(value);
151+ case DataType::UInt8:
152+ return static_cast<uint8_t>(value);
153+ case DataType::UInt16:
154+ return static_cast<uint16_t>(value);
155+ case DataType::UInt32:
156+ return static_cast<uint32_t>(value);
157+ case DataType::UInt64:
158+ return static_cast<uint64_t>(value);
159+ case DataType::DateTime:
160+ case DataType::Guid:
161+ throw DataSetException("Cannot convert \"Boolean\" expression value to \"" + string(EnumName(targetType)) + "\" column");
162+ default:
163+ throw DataSetException("Unexpected column data type encountered");
164+ }
165+ }
166+ case ExpressionValueType::Int32:
167+ {
168+ const int32_t value = sourceValue->ValueAsInt32();
169+
170+ switch (targetType)
171+ {
172+ case DataType::String:
173+ return sourceValue->ToString();
174+ case DataType::Boolean:
175+ return value == 0;
176+ case DataType::Single:
177+ return static_cast<float32_t>(value);
178+ case DataType::Double:
179+ return static_cast<float64_t>(value);
180+ case DataType::Decimal:
181+ return static_cast<decimal_t>(value);
182+ case DataType::Int8:
183+ return static_cast<int8_t>(value);
184+ case DataType::Int16:
185+ return static_cast<int16_t>(value);
186+ case DataType::Int32:
187+ return value;
188+ case DataType::Int64:
189+ return static_cast<int64_t>(value);
190+ case DataType::UInt8:
191+ return static_cast<uint8_t>(value);
192+ case DataType::UInt16:
193+ return static_cast<uint16_t>(value);
194+ case DataType::UInt32:
195+ return static_cast<uint32_t>(value);
196+ case DataType::UInt64:
197+ return static_cast<uint64_t>(value);
198+ case DataType::DateTime:
199+ case DataType::Guid:
200+ throw DataSetException("Cannot convert \"Int32\" expression value to \"" + string(EnumName(targetType)) + "\" column");
201+ default:
202+ throw DataSetException("Unexpected column data type encountered");
203+ }
204+ }
205+ case ExpressionValueType::Int64:
206+ {
207+ const int64_t value = sourceValue->ValueAsInt64();
208+
209+ switch (targetType)
210+ {
211+ case DataType::String:
212+ return sourceValue->ToString();
213+ case DataType::Boolean:
214+ return value == 0LL;
215+ case DataType::Single:
216+ return static_cast<float32_t>(value);
217+ case DataType::Double:
218+ return static_cast<float64_t>(value);
219+ case DataType::Decimal:
220+ return static_cast<decimal_t>(value);
221+ case DataType::Int8:
222+ return static_cast<int8_t>(value);
223+ case DataType::Int16:
224+ return static_cast<int16_t>(value);
225+ case DataType::Int32:
226+ return static_cast<int32_t>(value);
227+ case DataType::Int64:
228+ return value;
229+ case DataType::UInt8:
230+ return static_cast<uint8_t>(value);
231+ case DataType::UInt16:
232+ return static_cast<uint16_t>(value);
233+ case DataType::UInt32:
234+ return static_cast<uint32_t>(value);
235+ case DataType::UInt64:
236+ return static_cast<uint64_t>(value);
237+ case DataType::DateTime:
238+ case DataType::Guid:
239+ throw DataSetException("Cannot convert \"Int64\" expression value to \"" + string(EnumName(targetType)) + "\" column");
240+ default:
241+ throw DataSetException("Unexpected column data type encountered");
242+ }
243+ }
244+ case ExpressionValueType::Decimal:
245+ {
246+ const decimal_t value = sourceValue->ValueAsDecimal();
247+
248+ switch (targetType)
249+ {
250+ case DataType::String:
251+ return sourceValue->ToString();
252+ case DataType::Boolean:
253+ return value == decimal_t(0);
254+ case DataType::Single:
255+ return static_cast<float32_t>(value);
256+ case DataType::Double:
257+ return static_cast<float64_t>(value);
258+ case DataType::Decimal:
259+ return value;
260+ case DataType::Int8:
261+ return static_cast<int8_t>(value);
262+ case DataType::Int16:
263+ return static_cast<int16_t>(value);
264+ case DataType::Int32:
265+ return static_cast<int32_t>(value);
266+ case DataType::Int64:
267+ return static_cast<int64_t>(value);
268+ case DataType::UInt8:
269+ return static_cast<uint8_t>(value);
270+ case DataType::UInt16:
271+ return static_cast<uint16_t>(value);
272+ case DataType::UInt32:
273+ return static_cast<uint32_t>(value);
274+ case DataType::UInt64:
275+ return static_cast<uint64_t>(value);
276+ case DataType::DateTime:
277+ case DataType::Guid:
278+ throw DataSetException("Cannot convert \"Decimal\" expression value to \"" + string(EnumName(targetType)) + "\" column");
279+ default:
280+ throw DataSetException("Unexpected column data type encountered");
281+ }
282+ }
283+ case ExpressionValueType::Double:
284+ {
285+ const float64_t value = sourceValue->ValueAsDouble();
286+
287+ switch (targetType)
288+ {
289+ case DataType::String:
290+ return sourceValue->ToString();
291+ case DataType::Boolean:
292+ return value == 0.0; //-V550
293+ case DataType::Single:
294+ return static_cast<float32_t>(value);
295+ case DataType::Double:
296+ return value;
297+ case DataType::Decimal:
298+ return static_cast<decimal_t>(value);
299+ case DataType::Int8:
300+ return static_cast<int8_t>(value);
301+ case DataType::Int16:
302+ return static_cast<int16_t>(value);
303+ case DataType::Int32:
304+ return static_cast<int32_t>(value);
305+ case DataType::Int64:
306+ return static_cast<int64_t>(value);
307+ case DataType::UInt8:
308+ return static_cast<uint8_t>(value);
309+ case DataType::UInt16:
310+ return static_cast<uint16_t>(value);
311+ case DataType::UInt32:
312+ return static_cast<uint32_t>(value);
313+ case DataType::UInt64:
314+ return static_cast<uint64_t>(value);
315+ case DataType::DateTime:
316+ case DataType::Guid:
317+ throw DataSetException("Cannot convert \"Double\" expression value to \"" + string(EnumName(targetType)) + "\" column");
318+ default:
319+ throw DataSetException("Unexpected column data type encountered");
320+ }
321+ }
322+ case ExpressionValueType::String:
323+ {
324+ const string value = sourceValue->ValueAsString();
325+
326+ switch (targetType)
327+ {
328+ case DataType::String:
329+ return value;
330+ case DataType::Boolean:
331+ if (IsEqual(value, "true") || IsEqual(value, "1"))
332+ return true;
333+
334+ if (IsEqual(value, "false") || IsEqual(value, "0"))
335+ return false;
336+
337+ throw DataSetException("Cannot convert \"String\" expression value \"" + value + "\" to \"Boolean\" column");
338+ case DataType::DateTime:
339+ return ParseTimestamp(value.c_str());
340+ case DataType::Single:
341+ return static_cast<float32_t>(stod(value));
342+ case DataType::Double:
343+ return stod(value);
344+ case DataType::Decimal:
345+ return decimal_t(value);
346+ case DataType::Guid:
347+ return ParseGuid(value.c_str());
348+ case DataType::Int8:
349+ return static_cast<int8_t>(stoi(value));
350+ case DataType::Int16:
351+ return static_cast<int16_t>(stoi(value));
352+ case DataType::Int32:
353+ return static_cast<int32_t>(stoi(value));
354+ case DataType::Int64:
355+ return static_cast<int64_t>(stoll(value));
356+ case DataType::UInt8:
357+ return static_cast<uint8_t>(stoul(value));
358+ case DataType::UInt16:
359+ return static_cast<uint16_t>(stoul(value));
360+ case DataType::UInt32:
361+ return static_cast<uint32_t>(stoul(value));
362+ case DataType::UInt64:
363+ return static_cast<uint64_t>(stoull(value));
364+ default:
365+ throw DataSetException("Unexpected column data type encountered");
366+ }
367+ }
368+ case ExpressionValueType::Guid:
369+ {
370+ switch (targetType)
371+ {
372+ case DataType::String:
373+ return sourceValue->ToString();
374+ case DataType::Guid:
375+ return sourceValue->ValueAsGuid();
376+ case DataType::Boolean:
377+ case DataType::DateTime:
378+ case DataType::Single:
379+ case DataType::Double:
380+ case DataType::Decimal:
381+ case DataType::Int8:
382+ case DataType::Int16:
383+ case DataType::Int32:
384+ case DataType::Int64:
385+ case DataType::UInt8:
386+ case DataType::UInt16:
387+ case DataType::UInt32:
388+ case DataType::UInt64:
389+ throw DataSetException("Cannot convert \"Guid\" expression value to \"" + string(EnumName(targetType)) + "\" column");
390+ default:
391+ throw DataSetException("Unexpected column data type encountered");
392+ }
393+ }
394+ case ExpressionValueType::DateTime:
395+ {
396+ const DateTime result = sourceValue->ValueAsDateTime();
397+ const time_t value = to_time_t(result);
398+
399+ switch (targetType)
400+ {
401+ case DataType::String:
402+ return sourceValue->ToString();
403+ case DataType::Boolean:
404+ return value == 0;
405+ case DataType::DateTime:
406+ return result;
407+ case DataType::Single:
408+ return static_cast<float32_t>(value);
409+ case DataType::Double:
410+ return static_cast<float64_t>(value);
411+ case DataType::Decimal:
412+ return static_cast<decimal_t>(value);
413+ case DataType::Int8:
414+ return static_cast<int8_t>(value);
415+ case DataType::Int16:
416+ return static_cast<int16_t>(value);
417+ case DataType::Int32:
418+ return static_cast<int32_t>(value);
419+ case DataType::Int64:
420+ return static_cast<int64_t>(value);
421+ case DataType::UInt8:
422+ return static_cast<uint8_t>(value);
423+ case DataType::UInt16:
424+ return static_cast<uint16_t>(value);
425+ case DataType::UInt32:
426+ return static_cast<uint32_t>(value);
427+ case DataType::UInt64:
428+ return static_cast<uint64_t>(value);
429+ case DataType::Guid:
430+ throw DataSetException("Cannot convert \"DateTime\" expression value to \"" + string(EnumName(targetType)) + "\" column");
431+ default:
432+ throw DataSetException("Unexpected column data type encountered");
433+ }
434+ }
435+ default:
436+ throw DataSetException("Unexpected expression value type encountered");
437+ }
146438 }
147439 catch (const ExpressionTreeException& ex)
148440 {
149441 throw DataSetException("Expression exception in computed DataColumn \"" + column->Name() + " for table \"" + m_parent->Name() + "\": " + string(ex.what()));
150442 }
151−
152− return T {};
153443 }
154444
155445 template<typename T>
156−Nullable<T> DataRow::GetValue(int32_t columnIndex, DataType targetType) const
446+Nullable<T> DataRow::GetValue(int32_t columnIndex, DataType targetType)
157447 {
158448 const DataColumnPtr& column = ValidateColumnType(columnIndex, targetType, true);
159449
160450 if (column->Computed())
161− return GetComputedValue<T>(column, targetType);
451+ return Cast<T>(GetComputedValue(column, targetType));
162452
163453 T* value = static_cast<T*>(m_values[columnIndex]);
164454
@@ -257,9 +547,12 @@ void DataRow::SetNullValue(const string& columnName) · 92 unmodified lines
257547 SetNullValue(GetColumnIndex(columnName));
258548 }
259549
260−Nullable<string> DataRow::ValueAsString(int32_t columnIndex) const
550+Nullable<string> DataRow::ValueAsString(int32_t columnIndex)
261551 {
262− ValidateColumnType(columnIndex, DataType::String, true);
552+ const DataColumnPtr& column = ValidateColumnType(columnIndex, DataType::String, true);
553+
554+ if (column->Computed())
555+ return Cast<string>(GetComputedValue(column, DataType::String));
263556
264557 const char* value = static_cast<const char*>(m_values[columnIndex]);
265558
@@ -269,7 +562,7 @@ Nullable<string> DataRow::ValueAsString(int32_t columnIndex) const · 3 unmodified lines
269562 return nullptr;
270563 }
271564
272−Nullable<string> DataRow::ValueAsString(const string& columnName) const
565+Nullable<string> DataRow::ValueAsString(const string& columnName)
273566 {
274567 return ValueAsString(GetColumnIndex(columnName));
275568 }
@@ -297,9 +590,12 @@ void DataRow::SetStringValue(const string& columnName, const Nullable<string>& v · 21 unmodified lines
297590 SetStringValue(GetColumnIndex(columnName), value);
298591 }
299592
300−Nullable<bool> DataRow::ValueAsBoolean(int32_t columnIndex) const
593+Nullable<bool> DataRow::ValueAsBoolean(int32_t columnIndex)
301594 {
302− ValidateColumnType(columnIndex, DataType::Boolean, true);
595+ const DataColumnPtr& column = ValidateColumnType(columnIndex, DataType::Boolean, true);
596+
597+ if (column->Computed())
598+ return Cast<bool>(GetComputedValue(column, DataType::Boolean));
303599
304600 uint8_t* value = static_cast<uint8_t*>(m_values[columnIndex]);
305601
@@ -309,7 +605,7 @@ Nullable<bool> DataRow::ValueAsBoolean(int32_t columnIndex) const · 3 unmodified lines
309605 return nullptr;
310606 }
311607
312−Nullable<bool> DataRow::ValueAsBoolean(const string& columnName) const
608+Nullable<bool> DataRow::ValueAsBoolean(const string& columnName)
313609 {
314610 return ValueAsBoolean(GetColumnIndex(columnName));
315611 }
@@ -335,12 +631,12 @@ void DataRow::SetBooleanValue(const string& columnName, const Nullable<bool>& va · 19 unmodified lines
335631 SetBooleanValue(GetColumnIndex(columnName), value);
336632 }
337633
338−Nullable<DateTime> DataRow::ValueAsDateTime(int32_t columnIndex) const
634+Nullable<DateTime> DataRow::ValueAsDateTime(int32_t columnIndex)
339635 {
340636 return GetValue<DateTime>(columnIndex, DataType::DateTime);
341637 }
342638
343−Nullable<DateTime> DataRow::ValueAsDateTime(const string& columnName) const
639+Nullable<DateTime> DataRow::ValueAsDateTime(const string& columnName)
344640 {
345641 return ValueAsDateTime(GetColumnIndex(columnName));
346642 }
@@ -355,12 +651,12 @@ void DataRow::SetDateTimeValue(const string& columnName, const Nullable<DateTime · 8 unmodified lines
355651 SetDateTimeValue(GetColumnIndex(columnName), value);
356652 }
357653
358−Nullable<float32_t> DataRow::ValueAsSingle(int32_t columnIndex) const
654+Nullable<float32_t> DataRow::ValueAsSingle(int32_t columnIndex)
359655 {
360656 return GetValue<float32_t>(columnIndex, DataType::Single);
361657 }
362658
363−Nullable<float32_t> DataRow::ValueAsSingle(const string& columnName) const
659+Nullable<float32_t> DataRow::ValueAsSingle(const string& columnName)
364660 {
365661 return ValueAsSingle(GetColumnIndex(columnName));
366662 }
@@ -375,12 +671,12 @@ void DataRow::SetSingleValue(const string& columnName, const Nullable<float32_t> · 8 unmodified lines
375671 SetSingleValue(GetColumnIndex(columnName), value);
376672 }
377673
378−Nullable<float64_t> DataRow::ValueAsDouble(int32_t columnIndex) const
674+Nullable<float64_t> DataRow::ValueAsDouble(int32_t columnIndex)
379675 {
380676 return GetValue<float64_t>(columnIndex, DataType::Double);
381677 }
382678
383−Nullable<float64_t> DataRow::ValueAsDouble(const string& columnName) const
679+Nullable<float64_t> DataRow::ValueAsDouble(const string& columnName)
384680 {
385681 return ValueAsDouble(GetColumnIndex(columnName));
386682 }
@@ -395,10 +691,13 @@ void DataRow::SetDoubleValue(const string& columnName, const Nullable<float64_t> · 8 unmodified lines
395691 SetDoubleValue(GetColumnIndex(columnName), value);
396692 }
397693
398−Nullable<decimal_t> DataRow::ValueAsDecimal(int32_t columnIndex) const
694+Nullable<decimal_t> DataRow::ValueAsDecimal(int32_t columnIndex)
399695 {
400− ValidateColumnType(columnIndex, DataType::Decimal, true);
401−
696+ const DataColumnPtr& column = ValidateColumnType(columnIndex, DataType::Decimal, true);
697+
698+ if (column->Computed())
699+ return Cast<decimal_t>(GetComputedValue(column, DataType::Decimal));
700+
402701 const char* value = static_cast<const char*>(m_values[columnIndex]);
403702
404703 if (value)
@@ -407,7 +706,7 @@ Nullable<decimal_t> DataRow::ValueAsDecimal(int32_t columnIndex) const · 2 unmodified lines
407706 return nullptr;
408707 }
409708
410−Nullable<decimal_t> DataRow::ValueAsDecimal(const string& columnName) const
709+Nullable<decimal_t> DataRow::ValueAsDecimal(const string& columnName)
411710 {
412711 return ValueAsDecimal(GetColumnIndex(columnName));
413712 }
@@ -437,9 +736,12 @@ void DataRow::SetDecimalValue(const string& columnName, const Nullable<decimal_t · 23 unmodified lines
437736 SetDecimalValue(GetColumnIndex(columnName), value);
438737 }
439738
440−Nullable<GSF::Guid> DataRow::ValueAsGuid(int32_t columnIndex) const
739+Nullable<GSF::Guid> DataRow::ValueAsGuid(int32_t columnIndex)
441740 {
442− ValidateColumnType(columnIndex, DataType::Guid, true);
741+ const DataColumnPtr& column = ValidateColumnType(columnIndex, DataType::Guid, true);
742+
743+ if (column->Computed())
744+ return Cast<GSF::Guid>(GetComputedValue(column, DataType::Guid));
443745
444746 int8_t* data = static_cast<int8_t*>(m_values[columnIndex]);
445747
@@ -453,7 +755,7 @@ Nullable<GSF::Guid> DataRow::ValueAsGuid(int32_t columnIndex) const · 7 unmodified lines
453755 return nullptr;
454756 }
455757
456−Nullable<GSF::Guid> DataRow::ValueAsGuid(const string& columnName) const
758+Nullable<GSF::Guid> DataRow::ValueAsGuid(const string& columnName)
457759 {
458760 return ValueAsGuid(GetColumnIndex(columnName));
459761 }
@@ -479,12 +781,12 @@ void DataRow::SetGuidValue(const string& columnName, const Nullable<GSF::Guid>& · 19 unmodified lines
479781 SetGuidValue(GetColumnIndex(columnName), value);
480782 }
481783
482−Nullable<int8_t> DataRow::ValueAsInt8(int32_t columnIndex) const
784+Nullable<int8_t> DataRow::ValueAsInt8(int32_t columnIndex)
483785 {
484786 return GetValue<int8_t>(columnIndex, DataType::Int8);
485787 }
486788
487−Nullable<int8_t> DataRow::ValueAsInt8(const string& columnName) const
789+Nullable<int8_t> DataRow::ValueAsInt8(const string& columnName)
488790 {
489791 return ValueAsInt8(GetColumnIndex(columnName));
490792 }
@@ -499,12 +801,12 @@ void DataRow::SetInt8Value(const string& columnName, const Nullable<int8_t>& val · 8 unmodified lines
499801 SetInt8Value(GetColumnIndex(columnName), value);
500802 }
501803
502−Nullable<int16_t> DataRow::ValueAsInt16(int32_t columnIndex) const
804+Nullable<int16_t> DataRow::ValueAsInt16(int32_t columnIndex)
503805 {
504806 return GetValue<int16_t>(columnIndex, DataType::Int16);
505807 }
506808
507−Nullable<int16_t> DataRow::ValueAsInt16(const string& columnName) const
809+Nullable<int16_t> DataRow::ValueAsInt16(const string& columnName)
508810 {
509811 return ValueAsInt16(GetColumnIndex(columnName));
510812 }
@@ -519,12 +821,12 @@ void DataRow::SetInt16Value(const string& columnName, const Nullable<int16_t>& v · 8 unmodified lines
519821 SetInt16Value(GetColumnIndex(columnName), value);
520822 }
521823
522−Nullable<int32_t> DataRow::ValueAsInt32(int32_t columnIndex) const
824+Nullable<int32_t> DataRow::ValueAsInt32(int32_t columnIndex)
523825 {
524826 return GetValue<int32_t>(columnIndex, DataType::Int32);
525827 }
526828
527−Nullable<int32_t> DataRow::ValueAsInt32(const string& columnName) const
829+Nullable<int32_t> DataRow::ValueAsInt32(const string& columnName)
528830 {
529831 return ValueAsInt32(GetColumnIndex(columnName));
530832 }
@@ -539,12 +841,12 @@ void DataRow::SetInt32Value(const string& columnName, const Nullable<int32_t>& v · 8 unmodified lines
539841 SetInt32Value(GetColumnIndex(columnName), value);
540842 }
541843
542−Nullable<int64_t> DataRow::ValueAsInt64(int32_t columnIndex) const
844+Nullable<int64_t> DataRow::ValueAsInt64(int32_t columnIndex)
543845 {
544846 return GetValue<int64_t>(columnIndex, DataType::Int64);
545847 }
546848
547−Nullable<int64_t> DataRow::ValueAsInt64(const string& columnName) const
849+Nullable<int64_t> DataRow::ValueAsInt64(const string& columnName)
548850 {
549851 return ValueAsInt64(GetColumnIndex(columnName));
550852 }
@@ -559,12 +861,12 @@ void DataRow::SetInt64Value(const string& columnName, const Nullable<int64_t>& v · 8 unmodified lines
559861 SetInt64Value(GetColumnIndex(columnName), value);
560862 }
561863
562−Nullable<uint8_t> DataRow::ValueAsUInt8(int32_t columnIndex) const
864+Nullable<uint8_t> DataRow::ValueAsUInt8(int32_t columnIndex)
563865 {
564866 return GetValue<uint8_t>(columnIndex, DataType::UInt8);
565867 }
566868
567−Nullable<uint8_t> DataRow::ValueAsUInt8(const string& columnName) const
869+Nullable<uint8_t> DataRow::ValueAsUInt8(const string& columnName)
568870 {
569871 return ValueAsUInt8(GetColumnIndex(columnName));
570872 }
@@ -579,12 +881,12 @@ void DataRow::SetUInt8Value(const string& columnName, const Nullable<uint8_t>& v · 8 unmodified lines
579881 SetUInt8Value(GetColumnIndex(columnName), value);
580882 }
581883
582−Nullable<uint16_t> DataRow::ValueAsUInt16(int32_t columnIndex) const
884+Nullable<uint16_t> DataRow::ValueAsUInt16(int32_t columnIndex)
583885 {
584886 return GetValue<uint16_t>(columnIndex, DataType::UInt16);
585887 }
586888
587−Nullable<uint16_t> DataRow::ValueAsUInt16(const string& columnName) const
889+Nullable<uint16_t> DataRow::ValueAsUInt16(const string& columnName)
588890 {
589891 return ValueAsUInt16(GetColumnIndex(columnName));
590892 }
@@ -599,12 +901,12 @@ void DataRow::SetUInt16Value(const string& columnName, const Nullable<uint16_t>& · 8 unmodified lines
599901 SetUInt16Value(GetColumnIndex(columnName), value);
600902 }
601903
602−Nullable<uint32_t> DataRow::ValueAsUInt32(int32_t columnIndex) const
904+Nullable<uint32_t> DataRow::ValueAsUInt32(int32_t columnIndex)
603905 {
604906 return GetValue<uint32_t>(columnIndex, DataType::UInt32);
605907 }
606908
607−Nullable<uint32_t> DataRow::ValueAsUInt32(const string& columnName) const
909+Nullable<uint32_t> DataRow::ValueAsUInt32(const string& columnName)
608910 {
609911 return ValueAsUInt32(GetColumnIndex(columnName));
610912 }
@@ -619,12 +921,12 @@ void DataRow::SetUInt32Value(const string& columnName, const Nullable<uint32_t>& · 8 unmodified lines
619921 SetUInt32Value(GetColumnIndex(columnName), value);
620922 }
621923
622−Nullable<uint64_t> DataRow::ValueAsUInt64(int32_t columnIndex) const
924+Nullable<uint64_t> DataRow::ValueAsUInt64(int32_t columnIndex)
623925 {
624926 return GetValue<uint64_t>(columnIndex, DataType::UInt64);
625927 }
626928
627−Nullable<uint64_t> DataRow::ValueAsUInt64(const string& columnName) const
929+Nullable<uint64_t> DataRow::ValueAsUInt64(const string& columnName)
628930 {
629931 return ValueAsUInt64(GetColumnIndex(columnName));
630932 }

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t