C++ API Reference for Intel® Data Analytics Acceleration Library 2020 Update 1

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

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