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

data_management/data_source/modifiers/sql/internal/engine.h
1 /* file: engine.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_SOURCE_MODIFIERS_SQL_INTERNAL_ENGINE_H__
19 #define __DATA_SOURCE_MODIFIERS_SQL_INTERNAL_ENGINE_H__
20 
21 #include "services/internal/error_handling_helpers.h"
22 #include "data_management/features/internal/helpers.h"
23 #include "data_management/data_source/internal/sql_feature_utils.h"
24 #include "data_management/data_source/modifiers/internal/engine.h"
25 #include "data_management/data_source/modifiers/sql/modifier.h"
26 
27 namespace daal
28 {
29 namespace data_management
30 {
31 namespace modifiers
32 {
33 namespace sql
34 {
35 namespace internal
36 {
37 
38 using data_management::internal::SQLFeatureInfo;
39 using data_management::internal::SQLFeaturesInfo;
40 using data_management::internal::SQLFetchBuffer;
41 using data_management::internal::SQLFetchBufferFragment;
42 
47 class InputFeatureInfo : public modifiers::internal::InputFeatureInfo
48 {
49 public:
50  InputFeatureInfo() { }
51 
52  explicit InputFeatureInfo(const SQLFeatureInfo &featureInfo,
53  const SQLFetchBufferFragment &fetchBuffer) :
54  _featureInfo(featureInfo),
55  _fetchBuffer(fetchBuffer) { }
56 
57  const SQLFeatureInfo &getFeatureInfo() const
58  {
59  return _featureInfo;
60  }
61 
62  const SQLFetchBufferFragment &getFetchBuffer() const
63  {
64  return _fetchBuffer;
65  }
66 
67 private:
68  SQLFeatureInfo _featureInfo;
69  SQLFetchBufferFragment _fetchBuffer;
70 };
71 
76 class OutputFeatureInfo : public modifiers::internal::OutputFeatureInfo { };
77 
82 class ConfigImpl : public Config,
83  public modifiers::internal::Config<InputFeatureInfo,
84  OutputFeatureInfo>
85 {
86 private:
87  typedef modifiers::internal::Config<InputFeatureInfo,
88  OutputFeatureInfo> impl;
89 
90 public:
91  ConfigImpl() { }
92 
93  explicit ConfigImpl(const services::internal::CollectionPtr<InputFeatureInfo *> &pickedInputFeatures,
94  services::Status *status = NULL) :
95  impl(pickedInputFeatures, status) { }
96 
97  virtual size_t getNumberOfInputFeatures() const DAAL_C11_OVERRIDE
98  {
99  return impl::getNumberOfInputFeatures();
100  }
101 
102  virtual services::Status setNumberOfOutputFeatures(size_t numberOfOutputFeatures) DAAL_C11_OVERRIDE
103  {
104  return impl::setNumberOfOutputFeatures(numberOfOutputFeatures);
105  }
106 
107  virtual services::Status setOutputFeatureType(size_t outputFeatureIndex,
108  features::FeatureType featureType) DAAL_C11_OVERRIDE
109  {
110  return impl::setOutputFeatureType(outputFeatureIndex, featureType);
111  }
112 
113  virtual services::Status setNumberOfCategories(size_t outputFeatureIndex,
114  size_t numberOfCategories) DAAL_C11_OVERRIDE
115  {
116  return impl::setNumberOfCategories(outputFeatureIndex, numberOfCategories);
117  }
118 
119  virtual services::Status setCategoricalDictionary(size_t outputFeatureIndex,
120  const CategoricalFeatureDictionaryPtr &dictionary) DAAL_C11_OVERRIDE
121  {
122  return impl::setCategoricalDictionary(outputFeatureIndex, dictionary);
123  }
124 };
125 
130 class ContextImpl : public Context,
131  public modifiers::internal::Context<InputFeatureInfo,
132  OutputFeatureInfo>
133 {
134 private:
135  typedef modifiers::internal::Context<InputFeatureInfo,
136  OutputFeatureInfo> impl;
137 
138 public:
139  ContextImpl() { }
140 
141  explicit ContextImpl(const services::internal::CollectionPtr<InputFeatureInfo *> &pickedInputFeatures,
142  services::Status *status = NULL) :
143  impl(pickedInputFeatures, status) { }
144 
145  virtual size_t getNumberOfColumns() const DAAL_C11_OVERRIDE
146  {
147  return impl::getNumberOfInputFeatures();
148  }
149 
150  virtual services::BufferView<DAAL_DATA_TYPE> getOutputBuffer() const DAAL_C11_OVERRIDE
151  {
152  return impl::getOutputBuffer();
153  }
154 
155  virtual services::BufferView<char> getRawValue(size_t columnIndex) const DAAL_C11_OVERRIDE
156  {
157  const InputFeatureInfo &fi = impl::getPickedInputFeature(columnIndex);
158  return fi.getFetchBuffer().view();
159  }
160 };
161 
166 class ModifiersManager : public modifiers::internal::ModifiersManager<FeatureModifierIface,
167  ConfigImpl, ContextImpl>
168 {
169 public:
170  static services::SharedPtr<ModifiersManager> create(services::Status *status = NULL)
171  {
172  return services::internal::wrapSharedAndTryThrow(new ModifiersManager(), status);
173  }
174 
175  services::Status prepare(const SQLFeaturesInfo &featuresInfo,
176  const SQLFetchBuffer &fetchBuffer)
177  {
178  services::Status status;
179 
180  const features::FeatureIdMappingIfacePtr mapping = createMapping(featuresInfo, &status);
181  DAAL_CHECK_STATUS_VAR(status);
182 
183  const services::internal::CollectionPtr<InputFeatureInfo> inputFeaturesInfo =
184  createInputFeaturesInfo(featuresInfo, fetchBuffer, &status);
185  DAAL_CHECK_STATUS_VAR(status);
186 
187  status |= getBinder().bind(mapping, inputFeaturesInfo);
188 
189  return status;
190  }
191 
192 private:
193  ModifiersManager() { }
194 
195  services::internal::CollectionPtr<InputFeatureInfo> createInputFeaturesInfo(const SQLFeaturesInfo &featuresInfo,
196  const SQLFetchBuffer &fetchBuffer,
197  services::Status *status = NULL)
198  {
199  const size_t numberOfFeatures = featuresInfo.getNumberOfFeatures();
200 
201  services::internal::CollectionPtr<InputFeatureInfo> inputFeaturesInfo =
202  services::internal::HeapAllocatableCollection<InputFeatureInfo>::create(numberOfFeatures);
203  if (!inputFeaturesInfo)
204  {
205  services::internal::tryAssignStatusAndThrow(status, services::ErrorMemoryAllocationFailed);
206  return inputFeaturesInfo;
207  }
208 
209  for (size_t i = 0; i < numberOfFeatures; i++)
210  {
211  const SQLFeatureInfo &fi = featuresInfo[i];
212  const SQLFetchBufferFragment &ff = fetchBuffer.getFragment(i);
213  (*inputFeaturesInfo)[i] = InputFeatureInfo(fi, ff);
214  }
215 
216  return inputFeaturesInfo;
217  }
218 
219  features::FeatureIdMappingIfacePtr createMapping(const SQLFeaturesInfo &featuresInfo,
220  services::Status *status = NULL)
221  {
222  const size_t numberOfFeatures = featuresInfo.getNumberOfFeatures();
223 
224  services::Status localStatus;
225  const features::internal::FeatureIdDefaultMappingPtr mapping =
226  features::internal::FeatureIdDefaultMapping::create(numberOfFeatures, &localStatus);
227  if (!localStatus)
228  {
229  services::internal::tryAssignStatusAndThrow(status, localStatus);
230  return mapping;
231  }
232 
233  for (size_t i = 0; i < numberOfFeatures; ++i)
234  {
235  mapping->setFeatureKey(i, featuresInfo[i].columnName);
236  }
237 
238  return mapping;
239  }
240 };
241 typedef services::SharedPtr<ModifiersManager> ModifiersManagerPtr;
242 
243 } // namespace internal
244 } // namespace sql
245 } // namespace modifiers
246 } // namespace data_management
247 } // namespace daal
248 
249 #endif
daal::data_management::modifiers::internal::Context
Base class for modifier context.
Definition: data_management/data_source/modifiers/internal/engine.h:216
daal::data_management::modifiers::internal::ModifiersManager
Class that holds modifiers and implements logic of modifiers applying flow.
Definition: data_management/data_source/modifiers/internal/engine.h:451
daal::data_management::modifiers::sql::internal::ConfigImpl
Internal implementation of feature modifier configuration.
Definition: data_management/data_source/modifiers/sql/internal/engine.h:82
daal::data_management::modifiers::internal::Config
Base class for modifier configuration.
Definition: data_management/data_source/modifiers/internal/engine.h:102
daal::services::internal::HeapAllocatableCollection
Wrapper for services::Collection that allocates and deallocates memory using internal new/delete oper...
Definition: internal/collection.h:94
daal::data_management::modifiers::sql::internal::ContextImpl
Internal implementation of feature modifier context.
Definition: data_management/data_source/modifiers/sql/internal/engine.h:130
daal::data_management::modifiers::internal::InputFeatureInfo
Base class represents input feature for modifier, contains information about single input feature...
Definition: data_management/data_source/modifiers/internal/engine.h:37
daal::services::internal::CollectionPtr
Shared pointer to the Collection object.
Definition: internal/collection.h:138
daal::data_management::modifiers::sql::internal::InputFeatureInfo
Class represents configuration of single input feature.
Definition: data_management/data_source/modifiers/sql/internal/engine.h:47
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:150
daal::data_management::modifiers::sql::internal::OutputFeatureInfo
Class represents configuration of single feature.
Definition: data_management/data_source/modifiers/sql/internal/engine.h:76
daal::data_management::modifiers::sql::internal::ModifiersManager
Class that holds modifiers and implements logic of modifiers applying flow.
Definition: data_management/data_source/modifiers/sql/internal/engine.h:166
daal::data_management::modifiers::internal::OutputFeatureInfo
Base class represents output feature for modifier, contains information about single output feature...
Definition: data_management/data_source/modifiers/internal/engine.h:43

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