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
84 return column;84 return column;
85}85}
86 86
87ValueExpressionPtr DataRow::EvaluateExpression(const DataColumnPtr& column)87ExpressionTreePtr DataRow::GetExpressionTree(const DataColumnPtr& column)
88{88{
89 const int columnIndex = column->Index();89 const int columnIndex = column->Index();
90 90
91 FilterExpressionParser* parser = static_cast<FilterExpressionParser*>(m_values[columnIndex]);91 FilterExpressionParser* parser = static_cast<FilterExpressionParser*>(m_values[columnIndex]);
92 92
93 if (parser)93 if (parser)
94 return parser->GetExpressionTrees()[0]->Evaluate(shared_from_this());94 return parser->GetExpressionTrees()[0];
95 95
96 const DataTablePtr dataTable = column->Parent();96 const DataTablePtr& dataTable = column->Parent();
97 parser = new FilterExpressionParser(column->Expression());97 parser = new FilterExpressionParser(column->Expression());
98 98
99 parser->SetDataSet(dataTable->Parent());99 parser->SetDataSet(dataTable->Parent());
@@ -111,54 +111,344 @@ ValueExpressionPtr DataRow::EvaluateExpression(const DataColumnPtr& column) · 11 unmodified lines
111 111
112 m_values[columnIndex] = parser;112 m_values[columnIndex] = parser;
113 113
114 return expressionTrees[0]->Evaluate(shared_from_this());114 return expressionTrees[0];
115}115}
116 116
117template<typename T>117Object DataRow::GetComputedValue(const DataColumnPtr& column, DataType targetType)
118T DataRow::GetComputedValue(const DataColumnPtr& column, DataType targetType) const
119{118{
120 try119 try
121 {120 {
122 //const ValueExpressionPtr computedValue = EvaluateExpression(column);121 const ExpressionTreePtr& expressionTree = GetExpressionTree(column);
123 122 const ValueExpressionPtr& sourceValue = expressionTree->Evaluate(shared_from_this());
124 // TODO: Evaluate value for type T123
125 //switch (computedValue->ValueType)124 switch (sourceValue->ValueType)
126 //{125 {
127 // case ExpressionValueType::Boolean:126 case ExpressionValueType::Boolean:
128 // break;127 {
129 // case ExpressionValueType::Int32:128 const bool result = sourceValue->ValueAsBoolean();
130 // break;129 const int32_t value = result ? 1 : 0;
131 // case ExpressionValueType::Int64:130
132 // break;131 switch (targetType)
133 // case ExpressionValueType::Decimal:132 {
134 // break;133 case DataType::String:
135 // case ExpressionValueType::Double:134 return sourceValue->ToString();
136 // break;135 case DataType::Boolean:
137 // case ExpressionValueType::String:136 return result;
138 // break;137 case DataType::Single:
139 // case ExpressionValueType::Guid:138 return static_cast<float32_t>(value);
140 // break;139 case DataType::Double:
141 // case ExpressionValueType::DateTime:140 return static_cast<float64_t>(value);
142 // break;141 case DataType::Decimal:
143 // default:142 return static_cast<decimal_t>(value);
144 // throw ExpressionTreeException("Unexpected expression value type encountered");143 case DataType::Int8:
145 //}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 }
146 }438 }
147 catch (const ExpressionTreeException& ex)439 catch (const ExpressionTreeException& ex)
148 {440 {
149 throw DataSetException("Expression exception in computed DataColumn \"" + column->Name() + " for table \"" + m_parent->Name() + "\": " + string(ex.what()));441 throw DataSetException("Expression exception in computed DataColumn \"" + column->Name() + " for table \"" + m_parent->Name() + "\": " + string(ex.what()));
150 }442 }
151
152 return T {};
153}443}
154 444
155template<typename T>445template<typename T>
156Nullable<T> DataRow::GetValue(int32_t columnIndex, DataType targetType) const446Nullable<T> DataRow::GetValue(int32_t columnIndex, DataType targetType)
157{447{
158 const DataColumnPtr& column = ValidateColumnType(columnIndex, targetType, true);448 const DataColumnPtr& column = ValidateColumnType(columnIndex, targetType, true);
159 449
160 if (column->Computed())450 if (column->Computed())
161 return GetComputedValue<T>(column, targetType);451 return Cast<T>(GetComputedValue(column, targetType));
162 452
163 T* value = static_cast<T*>(m_values[columnIndex]);453 T* value = static_cast<T*>(m_values[columnIndex]);
164 454
@@ -257,9 +547,12 @@ void DataRow::SetNullValue(const string& columnName) · 92 unmodified lines
257 SetNullValue(GetColumnIndex(columnName));547 SetNullValue(GetColumnIndex(columnName));
258}548}
259 549
260Nullable<string> DataRow::ValueAsString(int32_t columnIndex) const550Nullable<string> DataRow::ValueAsString(int32_t columnIndex)
261{551{
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));
263 556
264 const char* value = static_cast<const char*>(m_values[columnIndex]);557 const char* value = static_cast<const char*>(m_values[columnIndex]);
265 558
@@ -269,7 +562,7 @@ Nullable<string> DataRow::ValueAsString(int32_t columnIndex) const · 3 unmodified lines
269 return nullptr;562 return nullptr;
270}563}
271 564
272Nullable<string> DataRow::ValueAsString(const string& columnName) const565Nullable<string> DataRow::ValueAsString(const string& columnName)
273{566{
274 return ValueAsString(GetColumnIndex(columnName));567 return ValueAsString(GetColumnIndex(columnName));
275}568}
@@ -297,9 +590,12 @@ void DataRow::SetStringValue(const string& columnName, const Nullable<string>& v · 21 unmodified lines
297 SetStringValue(GetColumnIndex(columnName), value);590 SetStringValue(GetColumnIndex(columnName), value);
298}591}
299 592
300Nullable<bool> DataRow::ValueAsBoolean(int32_t columnIndex) const593Nullable<bool> DataRow::ValueAsBoolean(int32_t columnIndex)
301{594{
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));
303 599
304 uint8_t* value = static_cast<uint8_t*>(m_values[columnIndex]);600 uint8_t* value = static_cast<uint8_t*>(m_values[columnIndex]);
305 601
@@ -309,7 +605,7 @@ Nullable<bool> DataRow::ValueAsBoolean(int32_t columnIndex) const · 3 unmodified lines
309 return nullptr;605 return nullptr;
310}606}
311 607
312Nullable<bool> DataRow::ValueAsBoolean(const string& columnName) const608Nullable<bool> DataRow::ValueAsBoolean(const string& columnName)
313{609{
314 return ValueAsBoolean(GetColumnIndex(columnName));610 return ValueAsBoolean(GetColumnIndex(columnName));
315}611}
@@ -335,12 +631,12 @@ void DataRow::SetBooleanValue(const string& columnName, const Nullable<bool>& va · 19 unmodified lines
335 SetBooleanValue(GetColumnIndex(columnName), value);631 SetBooleanValue(GetColumnIndex(columnName), value);
336}632}
337 633
338Nullable<DateTime> DataRow::ValueAsDateTime(int32_t columnIndex) const634Nullable<DateTime> DataRow::ValueAsDateTime(int32_t columnIndex)
339{635{
340 return GetValue<DateTime>(columnIndex, DataType::DateTime);636 return GetValue<DateTime>(columnIndex, DataType::DateTime);
341}637}
342 638
343Nullable<DateTime> DataRow::ValueAsDateTime(const string& columnName) const639Nullable<DateTime> DataRow::ValueAsDateTime(const string& columnName)
344{640{
345 return ValueAsDateTime(GetColumnIndex(columnName));641 return ValueAsDateTime(GetColumnIndex(columnName));
346}642}
@@ -355,12 +651,12 @@ void DataRow::SetDateTimeValue(const string& columnName, const Nullable<DateTime · 8 unmodified lines
355 SetDateTimeValue(GetColumnIndex(columnName), value);651 SetDateTimeValue(GetColumnIndex(columnName), value);
356}652}
357 653
358Nullable<float32_t> DataRow::ValueAsSingle(int32_t columnIndex) const654Nullable<float32_t> DataRow::ValueAsSingle(int32_t columnIndex)
359{655{
360 return GetValue<float32_t>(columnIndex, DataType::Single);656 return GetValue<float32_t>(columnIndex, DataType::Single);
361}657}
362 658
363Nullable<float32_t> DataRow::ValueAsSingle(const string& columnName) const659Nullable<float32_t> DataRow::ValueAsSingle(const string& columnName)
364{660{
365 return ValueAsSingle(GetColumnIndex(columnName));661 return ValueAsSingle(GetColumnIndex(columnName));
366}662}
@@ -375,12 +671,12 @@ void DataRow::SetSingleValue(const string& columnName, const Nullable<float32_t> · 8 unmodified lines
375 SetSingleValue(GetColumnIndex(columnName), value);671 SetSingleValue(GetColumnIndex(columnName), value);
376}672}
377 673
378Nullable<float64_t> DataRow::ValueAsDouble(int32_t columnIndex) const674Nullable<float64_t> DataRow::ValueAsDouble(int32_t columnIndex)
379{675{
380 return GetValue<float64_t>(columnIndex, DataType::Double);676 return GetValue<float64_t>(columnIndex, DataType::Double);
381}677}
382 678
383Nullable<float64_t> DataRow::ValueAsDouble(const string& columnName) const679Nullable<float64_t> DataRow::ValueAsDouble(const string& columnName)
384{680{
385 return ValueAsDouble(GetColumnIndex(columnName));681 return ValueAsDouble(GetColumnIndex(columnName));
386}682}
@@ -395,10 +691,13 @@ void DataRow::SetDoubleValue(const string& columnName, const Nullable<float64_t> · 8 unmodified lines
395 SetDoubleValue(GetColumnIndex(columnName), value);691 SetDoubleValue(GetColumnIndex(columnName), value);
396}692}
397 693
398Nullable<decimal_t> DataRow::ValueAsDecimal(int32_t columnIndex) const694Nullable<decimal_t> DataRow::ValueAsDecimal(int32_t columnIndex)
399{695{
400 ValidateColumnType(columnIndex, DataType::Decimal, true);696 const DataColumnPtr& column = ValidateColumnType(columnIndex, DataType::Decimal, true);
401 697
698 if (column->Computed())
699 return Cast<decimal_t>(GetComputedValue(column, DataType::Decimal));
700
402 const char* value = static_cast<const char*>(m_values[columnIndex]);701 const char* value = static_cast<const char*>(m_values[columnIndex]);
403 702
404 if (value)703 if (value)
@@ -407,7 +706,7 @@ Nullable<decimal_t> DataRow::ValueAsDecimal(int32_t columnIndex) const · 2 unmodified lines
407 return nullptr;706 return nullptr;
408}707}
409 708
410Nullable<decimal_t> DataRow::ValueAsDecimal(const string& columnName) const709Nullable<decimal_t> DataRow::ValueAsDecimal(const string& columnName)
411{710{
412 return ValueAsDecimal(GetColumnIndex(columnName));711 return ValueAsDecimal(GetColumnIndex(columnName));
413}712}
@@ -437,9 +736,12 @@ void DataRow::SetDecimalValue(const string& columnName, const Nullable<decimal_t · 23 unmodified lines
437 SetDecimalValue(GetColumnIndex(columnName), value);736 SetDecimalValue(GetColumnIndex(columnName), value);
438}737}
439 738
440Nullable<GSF::Guid> DataRow::ValueAsGuid(int32_t columnIndex) const739Nullable<GSF::Guid> DataRow::ValueAsGuid(int32_t columnIndex)
441{740{
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));
443 745
444 int8_t* data = static_cast<int8_t*>(m_values[columnIndex]);746 int8_t* data = static_cast<int8_t*>(m_values[columnIndex]);
445 747
@@ -453,7 +755,7 @@ Nullable<GSF::Guid> DataRow::ValueAsGuid(int32_t columnIndex) const · 7 unmodified lines
453 return nullptr;755 return nullptr;
454}756}
455 757
456Nullable<GSF::Guid> DataRow::ValueAsGuid(const string& columnName) const758Nullable<GSF::Guid> DataRow::ValueAsGuid(const string& columnName)
457{759{
458 return ValueAsGuid(GetColumnIndex(columnName));760 return ValueAsGuid(GetColumnIndex(columnName));
459}761}
@@ -479,12 +781,12 @@ void DataRow::SetGuidValue(const string& columnName, const Nullable<GSF::Guid>& · 19 unmodified lines
479 SetGuidValue(GetColumnIndex(columnName), value);781 SetGuidValue(GetColumnIndex(columnName), value);
480}782}
481 783
482Nullable<int8_t> DataRow::ValueAsInt8(int32_t columnIndex) const784Nullable<int8_t> DataRow::ValueAsInt8(int32_t columnIndex)
483{785{
484 return GetValue<int8_t>(columnIndex, DataType::Int8);786 return GetValue<int8_t>(columnIndex, DataType::Int8);
485}787}
486 788
487Nullable<int8_t> DataRow::ValueAsInt8(const string& columnName) const789Nullable<int8_t> DataRow::ValueAsInt8(const string& columnName)
488{790{
489 return ValueAsInt8(GetColumnIndex(columnName));791 return ValueAsInt8(GetColumnIndex(columnName));
490}792}
@@ -499,12 +801,12 @@ void DataRow::SetInt8Value(const string& columnName, const Nullable<int8_t>& val · 8 unmodified lines
499 SetInt8Value(GetColumnIndex(columnName), value);801 SetInt8Value(GetColumnIndex(columnName), value);
500}802}
501 803
502Nullable<int16_t> DataRow::ValueAsInt16(int32_t columnIndex) const804Nullable<int16_t> DataRow::ValueAsInt16(int32_t columnIndex)
503{805{
504 return GetValue<int16_t>(columnIndex, DataType::Int16);806 return GetValue<int16_t>(columnIndex, DataType::Int16);
505}807}
506 808
507Nullable<int16_t> DataRow::ValueAsInt16(const string& columnName) const809Nullable<int16_t> DataRow::ValueAsInt16(const string& columnName)
508{810{
509 return ValueAsInt16(GetColumnIndex(columnName));811 return ValueAsInt16(GetColumnIndex(columnName));
510}812}
@@ -519,12 +821,12 @@ void DataRow::SetInt16Value(const string& columnName, const Nullable<int16_t>& v · 8 unmodified lines
519 SetInt16Value(GetColumnIndex(columnName), value);821 SetInt16Value(GetColumnIndex(columnName), value);
520}822}
521 823
522Nullable<int32_t> DataRow::ValueAsInt32(int32_t columnIndex) const824Nullable<int32_t> DataRow::ValueAsInt32(int32_t columnIndex)
523{825{
524 return GetValue<int32_t>(columnIndex, DataType::Int32);826 return GetValue<int32_t>(columnIndex, DataType::Int32);
525}827}
526 828
527Nullable<int32_t> DataRow::ValueAsInt32(const string& columnName) const829Nullable<int32_t> DataRow::ValueAsInt32(const string& columnName)
528{830{
529 return ValueAsInt32(GetColumnIndex(columnName));831 return ValueAsInt32(GetColumnIndex(columnName));
530}832}
@@ -539,12 +841,12 @@ void DataRow::SetInt32Value(const string& columnName, const Nullable<int32_t>& v · 8 unmodified lines
539 SetInt32Value(GetColumnIndex(columnName), value);841 SetInt32Value(GetColumnIndex(columnName), value);
540}842}
541 843
542Nullable<int64_t> DataRow::ValueAsInt64(int32_t columnIndex) const844Nullable<int64_t> DataRow::ValueAsInt64(int32_t columnIndex)
543{845{
544 return GetValue<int64_t>(columnIndex, DataType::Int64);846 return GetValue<int64_t>(columnIndex, DataType::Int64);
545}847}
546 848
547Nullable<int64_t> DataRow::ValueAsInt64(const string& columnName) const849Nullable<int64_t> DataRow::ValueAsInt64(const string& columnName)
548{850{
549 return ValueAsInt64(GetColumnIndex(columnName));851 return ValueAsInt64(GetColumnIndex(columnName));
550}852}
@@ -559,12 +861,12 @@ void DataRow::SetInt64Value(const string& columnName, const Nullable<int64_t>& v · 8 unmodified lines
559 SetInt64Value(GetColumnIndex(columnName), value);861 SetInt64Value(GetColumnIndex(columnName), value);
560}862}
561 863
562Nullable<uint8_t> DataRow::ValueAsUInt8(int32_t columnIndex) const864Nullable<uint8_t> DataRow::ValueAsUInt8(int32_t columnIndex)
563{865{
564 return GetValue<uint8_t>(columnIndex, DataType::UInt8);866 return GetValue<uint8_t>(columnIndex, DataType::UInt8);
565}867}
566 868
567Nullable<uint8_t> DataRow::ValueAsUInt8(const string& columnName) const869Nullable<uint8_t> DataRow::ValueAsUInt8(const string& columnName)
568{870{
569 return ValueAsUInt8(GetColumnIndex(columnName));871 return ValueAsUInt8(GetColumnIndex(columnName));
570}872}
@@ -579,12 +881,12 @@ void DataRow::SetUInt8Value(const string& columnName, const Nullable<uint8_t>& v · 8 unmodified lines
579 SetUInt8Value(GetColumnIndex(columnName), value);881 SetUInt8Value(GetColumnIndex(columnName), value);
580}882}
581 883
582Nullable<uint16_t> DataRow::ValueAsUInt16(int32_t columnIndex) const884Nullable<uint16_t> DataRow::ValueAsUInt16(int32_t columnIndex)
583{885{
584 return GetValue<uint16_t>(columnIndex, DataType::UInt16);886 return GetValue<uint16_t>(columnIndex, DataType::UInt16);
585}887}
586 888
587Nullable<uint16_t> DataRow::ValueAsUInt16(const string& columnName) const889Nullable<uint16_t> DataRow::ValueAsUInt16(const string& columnName)
588{890{
589 return ValueAsUInt16(GetColumnIndex(columnName));891 return ValueAsUInt16(GetColumnIndex(columnName));
590}892}
@@ -599,12 +901,12 @@ void DataRow::SetUInt16Value(const string& columnName, const Nullable<uint16_t>& · 8 unmodified lines
599 SetUInt16Value(GetColumnIndex(columnName), value);901 SetUInt16Value(GetColumnIndex(columnName), value);
600}902}
601 903
602Nullable<uint32_t> DataRow::ValueAsUInt32(int32_t columnIndex) const904Nullable<uint32_t> DataRow::ValueAsUInt32(int32_t columnIndex)
603{905{
604 return GetValue<uint32_t>(columnIndex, DataType::UInt32);906 return GetValue<uint32_t>(columnIndex, DataType::UInt32);
605}907}
606 908
607Nullable<uint32_t> DataRow::ValueAsUInt32(const string& columnName) const909Nullable<uint32_t> DataRow::ValueAsUInt32(const string& columnName)
608{910{
609 return ValueAsUInt32(GetColumnIndex(columnName));911 return ValueAsUInt32(GetColumnIndex(columnName));
610}912}
@@ -619,12 +921,12 @@ void DataRow::SetUInt32Value(const string& columnName, const Nullable<uint32_t>& · 8 unmodified lines
619 SetUInt32Value(GetColumnIndex(columnName), value);921 SetUInt32Value(GetColumnIndex(columnName), value);
620}922}
621 923
622Nullable<uint64_t> DataRow::ValueAsUInt64(int32_t columnIndex) const924Nullable<uint64_t> DataRow::ValueAsUInt64(int32_t columnIndex)
623{925{
624 return GetValue<uint64_t>(columnIndex, DataType::UInt64);926 return GetValue<uint64_t>(columnIndex, DataType::UInt64);
625}927}
626 928
627Nullable<uint64_t> DataRow::ValueAsUInt64(const string& columnName) const929Nullable<uint64_t> DataRow::ValueAsUInt64(const string& columnName)
628{930{
629 return ValueAsUInt64(GetColumnIndex(columnName));931 return ValueAsUInt64(GetColumnIndex(columnName));
630}932}

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