C++ API Reference for Intel® Data Analytics Acceleration Library 2019 Update 4

sql_feature_utils.h
1 /* file: sql_feature_utils.h */
2 /*******************************************************************************
3 * Copyright 2014-2019 Intel Corporation.
4 *
5 * This software and the related documents are Intel copyrighted materials, and
6 * your use of them is governed by the express license under which they were
7 * provided to you (License). Unless the License provides otherwise, you may not
8 * use, modify, copy, publish, distribute, disclose or transmit this software or
9 * the related documents without Intel's prior written permission.
10 *
11 * This software and the related documents are provided as is, with no express
12 * or implied warranties, other than those that are expressly stated in the
13 * License.
14 *******************************************************************************/
15 
16 #ifndef __DATA_MANAGEMENT_DATA_SOURCE_INTERNAL_SQL_FEATURE_UTILS_H__
17 #define __DATA_MANAGEMENT_DATA_SOURCE_INTERNAL_SQL_FEATURE_UTILS_H__
18 
19 #include <string>
20 #include "services/collection.h"
21 #include "services/internal/buffer.h"
22 #include "services/internal/utilities.h"
23 
24 #if defined(_WIN32) || defined(_WIN64)
25 #include <windows.h>
26 #endif
27 
28 #include <sql.h>
29 #include <sqlext.h>
30 #include <sqltypes.h>
31 
32 namespace daal
33 {
34 namespace data_management
35 {
36 namespace internal
37 {
38 
43 class SQLFeatureInfo : public Base
44 {
45 public:
46  SQLSMALLINT sqlType;
47  SQLLEN sqlOctetLength;
48  services::String columnName;
49  bool isSigned;
50 
51  SQLFeatureInfo() :
52  sqlType(SQL_UNKNOWN_TYPE),
53  sqlOctetLength(0),
54  isSigned(false) { }
55 
56  explicit SQLFeatureInfo(const services::String &columnName,
57  SQLSMALLINT sqlType,
58  SQLLEN sqlOctetLength,
59  bool isSigned) :
60  columnName(columnName),
61  sqlType(sqlType),
62  sqlOctetLength(sqlOctetLength),
63  isSigned(isSigned) { }
64 };
65 
70 class SQLFeaturesInfo : public Base
71 {
72 public:
73  services::Status add(const SQLFeatureInfo &featureInfo)
74  {
75  _featuresInfo.safe_push_back(featureInfo);
76  return services::Status();
77  }
78 
79  const SQLFeatureInfo &get(size_t index) const
80  {
81  DAAL_ASSERT( index < _featuresInfo.size() );
82  return _featuresInfo[index];
83  }
84 
85  const SQLFeatureInfo &operator[](size_t index) const
86  {
87  return get(index);
88  }
89 
90  size_t getNumberOfFeatures() const
91  {
92  return _featuresInfo.size();
93  }
94 private:
95  services::Collection<SQLFeatureInfo> _featuresInfo;
96 };
97 
102 class SQLFetchBufferFragment : public Base
103 {
104 public:
105  SQLFetchBufferFragment() :
106  _rawFetchBuffer(NULL),
107  _bufferSize(0),
108  _actualDataSize(NULL) { }
109 
110  explicit SQLFetchBufferFragment(char *rawFetchBuffer,
111  SQLLEN bufferSize,
112  SQLLEN *actualDataSize) :
113  _rawFetchBuffer(rawFetchBuffer),
114  _bufferSize(bufferSize),
115  _actualDataSize(actualDataSize) { }
116 
117  char *getBuffer() const
118  {
119  return _rawFetchBuffer;
120  }
121 
122  SQLLEN getBufferSize() const
123  {
124  return _bufferSize;
125  }
126 
127  SQLLEN getActualDataSize() const
128  {
129  return *_actualDataSize;
130  }
131 
132  services::BufferView<char> view() const
133  {
134  return services::BufferView<char>(_rawFetchBuffer, *_actualDataSize);
135  }
136 
137 private:
138  char *_rawFetchBuffer;
139  SQLLEN _bufferSize;
140  SQLLEN *_actualDataSize;
141 };
142 
143 template<typename FloatingPointType>
144 inline SQLSMALLINT getSQLTypeForFloatingType();
145 
146 template<>
147 inline SQLSMALLINT getSQLTypeForFloatingType<double>()
148 { return SQL_C_DOUBLE; }
149 
150 template<>
151 inline SQLSMALLINT getSQLTypeForFloatingType<float>()
152 { return SQL_C_FLOAT; }
153 
158 class SQLFetchMode
159 {
160 public:
161  enum Value
162  {
163  useNativeSQLTypes,
164  castToFloatingPointType
165  };
166 
167  static SQLSMALLINT getTargetType(Value fetchMode)
168  {
169  switch (fetchMode)
170  {
171  case useNativeSQLTypes:
172  return SQL_C_DEFAULT;
173 
174  case castToFloatingPointType:
175  return getSQLTypeForFloatingType<DAAL_DATA_TYPE>();
176  }
177  return SQL_C_DEFAULT;
178  }
179 
180 private:
181  SQLFetchMode();
182 };
183 
189 class SQLFetchBuffer : public Base
190 {
191 public:
192  static services::SharedPtr<SQLFetchBuffer> create(const SQLFeaturesInfo &featuresInfo,
193  const SQLFetchMode::Value &mode,
194  services::Status *status = NULL)
195  {
196  return services::internal::wrapSharedAndTryThrow(
197  new SQLFetchBuffer(featuresInfo, mode, status), status);
198  }
199 
200  size_t getNumberOfFeatures() const
201  {
202  DAAL_ASSERT( _bufferOffsets.size() > 0 );
203  return _bufferOffsets.size() - 1;
204  }
205 
206  char *getBufferForFeature(size_t featureIndex) const
207  {
208  DAAL_ASSERT( _bufferOffsets.size() > 0 );
209  DAAL_ASSERT( featureIndex + 1 < _bufferOffsets.size() );
210  return _buffer.offset( _bufferOffsets[featureIndex] );
211  }
212 
213  SQLLEN *getActualDataSizeBufferForFeature(size_t featureIndex) const
214  {
215  DAAL_ASSERT( featureIndex < _actualDataSizes.size() );
216  return _actualDataSizes.offset(featureIndex);
217  }
218 
219  SQLLEN getBufferSizeForFeature(size_t featureIndex) const
220  {
221  DAAL_ASSERT( _bufferOffsets.size() > 0 );
222  DAAL_ASSERT( featureIndex + 1 < _bufferOffsets.size() );
223  const size_t begin = _bufferOffsets[featureIndex];
224  const size_t end = _bufferOffsets[featureIndex + 1];
225  return (SQLLEN)(end - begin);
226  }
227 
228  SQLLEN getActualDataSizeForFeature(size_t featureIndex) const
229  {
230  DAAL_ASSERT( featureIndex < _actualDataSizes.size() );
231  return _actualDataSizes[featureIndex];
232  }
233 
234  SQLFetchBufferFragment getFragment(size_t featureIndex) const
235  {
236  return SQLFetchBufferFragment( getBufferForFeature(featureIndex),
237  getBufferSizeForFeature(featureIndex),
238  getActualDataSizeBufferForFeature(featureIndex) );
239  }
240 
241  void copyTo(const services::BufferView<DAAL_DATA_TYPE> &buffer) const
242  {
243  DAAL_ASSERT( _mode == SQLFetchMode::castToFloatingPointType );
244 
245  char *rawFetchBuffer = _buffer.data();
246  DAAL_DATA_TYPE *targetBuffer = buffer.data();
247 
248  const size_t elementsToCopy = services::internal::minValue( buffer.size(),
249  getNumberOfFeatures() );
250  for (size_t i = 0; i < elementsToCopy; i++)
251  {
252  if (_actualDataSizes[i] == SQL_NULL_DATA)
253  {
254  targetBuffer[i] = DAAL_DATA_TYPE(0.0);
255  }
256  else
257  {
258  targetBuffer[i] = *( (DAAL_DATA_TYPE *)rawFetchBuffer );
259  }
260 
261  rawFetchBuffer += sizeof(DAAL_DATA_TYPE);
262  }
263  }
264 
265 private:
266  SQLFetchBuffer(const SQLFetchBuffer &);
267  SQLFetchBuffer &operator=(const SQLFetchBuffer &);
268 
269  explicit SQLFetchBuffer(const SQLFeaturesInfo &featuresInfo,
270  const SQLFetchMode::Value &mode,
271  services::Status *status = NULL) : _mode(mode)
272  {
273  services::internal::tryAssignStatusAndThrow(status, prepare(featuresInfo, mode));
274  }
275 
276  services::Status prepare(const SQLFeaturesInfo &featuresInfo,
277  const SQLFetchMode::Value &mode)
278  {
279  services::Status status;
280 
281  const size_t numberOfFeatures = featuresInfo.getNumberOfFeatures();
282  DAAL_CHECK_STATUS( status, _bufferOffsets.reallocate(numberOfFeatures + 1) );
283  DAAL_CHECK_STATUS( status, _actualDataSizes.reallocate(numberOfFeatures) );
284 
285  _bufferOffsets[0] = 0;
286  for (size_t i = 0; i < numberOfFeatures; i++)
287  {
288  const size_t bufferStride = (mode == SQLFetchMode::useNativeSQLTypes)
289  ? featuresInfo[i].sqlOctetLength
290  : sizeof(DAAL_DATA_TYPE);
291 
292  _bufferOffsets[i + 1] = _bufferOffsets[i] + bufferStride;
293  _actualDataSizes[i] = 0;
294  }
295 
296  const size_t bufferSize = _bufferOffsets[numberOfFeatures];
297  DAAL_CHECK_STATUS( status, _buffer.reallocate(bufferSize) );
298 
299  return status;
300  }
301 
302 private:
303  const SQLFetchMode::Value _mode;
304  services::internal::Buffer<char> _buffer;
305  services::internal::Buffer<SQLLEN> _bufferOffsets;
306  services::internal::Buffer<SQLLEN> _actualDataSizes;
307 };
308 typedef services::SharedPtr<SQLFetchBuffer> SQLFetchBufferPtr;
309 
310 } // namespace internal
311 } // namespace data_management
312 } // namespace daal
313 
314 #endif
daal::services::internal::Buffer< char >
daal
Definition: algorithm_base_common.h:31
daal::data_management::internal::SQLFetchBuffer
Class hold buffer for fetching data from SQL table, simplifies binding of SQL table columns...
Definition: sql_feature_utils.h:189
daal::data_management::internal::SQLFeatureInfo
Class that holds auxiliary information about single SQL column.
Definition: sql_feature_utils.h:43
daal::Base
Base class for Intel(R) Data Analytics Acceleration Library objects
Definition: base.h:39
daal::data_management::internal::SQLFetchBufferFragment
Represents fragment of SQL fetch buffer.
Definition: sql_feature_utils.h:102
daal::data_management::internal::SQLFetchMode
Mode of fetching data from SQL table.
Definition: sql_feature_utils.h:158
daal::data_management::internal::SQLFeaturesInfo
Class that holds auxiliary information about multiple SQL columns.
Definition: sql_feature_utils.h:70

For more complete information about compiler optimizations, see our Optimization Notice.