OmniSciDB  8a228a1076
import_export::Detector Class Reference

#include <Importer.h>

+ Inheritance diagram for import_export::Detector:
+ Collaboration diagram for import_export::Detector:

Public Member Functions

 Detector (const boost::filesystem::path &fp, CopyParams &cp)
 
std::vector< std::string > get_headers ()
 
std::vector< std::vector< std::string > > get_sample_rows (size_t n)
 
- Public Member Functions inherited from import_export::DataStreamSink
 DataStreamSink ()
 
 DataStreamSink (const CopyParams &copy_params, const std::string file_path)
 
virtual ~DataStreamSink ()
 
const CopyParamsget_copy_params () const
 
void import_compressed (std::vector< std::string > &file_paths)
 

Static Public Member Functions

static SQLTypes detect_sqltype (const std::string &str)
 

Public Attributes

std::vector< std::vector< std::string > > raw_rows
 
std::vector< SQLTypesbest_sqltypes
 
std::vector< EncodingTypebest_encodings
 
bool has_headers = false
 

Private Member Functions

void init ()
 
void read_file ()
 
void detect_row_delimiter ()
 
void split_raw_data ()
 
std::vector< SQLTypesdetect_column_types (const std::vector< std::string > &row)
 
void find_best_sqltypes ()
 
std::vector< SQLTypesfind_best_sqltypes (const std::vector< std::vector< std::string >> &raw_rows, const CopyParams &copy_params)
 
std::vector< SQLTypesfind_best_sqltypes (const std::vector< std::vector< std::string >>::const_iterator &row_begin, const std::vector< std::vector< std::string >>::const_iterator &row_end, const CopyParams &copy_params)
 
std::vector< EncodingTypefind_best_encodings (const std::vector< std::vector< std::string >>::const_iterator &row_begin, const std::vector< std::vector< std::string >>::const_iterator &row_end, const std::vector< SQLTypes > &best_types)
 
bool detect_headers (const std::vector< SQLTypes > &first_types, const std::vector< SQLTypes > &rest_types)
 
void find_best_sqltypes_and_headers ()
 
ImportStatus importDelimited (const std::string &file_path, const bool decompressed) override
 

Static Private Member Functions

static bool more_restrictive_sqltype (const SQLTypes a, const SQLTypes b)
 

Private Attributes

std::string raw_data
 
boost::filesystem::path file_path
 
std::chrono::duration< double > timeout {1}
 
std::string line1
 

Additional Inherited Members

- Protected Member Functions inherited from import_export::DataStreamSink
ImportStatus archivePlumber ()
 
- Protected Attributes inherited from import_export::DataStreamSink
CopyParams copy_params
 
const std::string file_path
 
FILE * p_file = nullptr
 
ImportStatus import_status
 
bool load_failed = false
 
size_t total_file_size {0}
 
std::vector< size_t > file_offsets
 
std::mutex file_offsets_mutex
 

Detailed Description

Definition at line 656 of file Importer.h.

Constructor & Destructor Documentation

◆ Detector()

import_export::Detector::Detector ( const boost::filesystem::path &  fp,
CopyParams cp 
)
inline

Definition at line 658 of file Importer.h.

References logger::init().

659  : DataStreamSink(cp, fp.string()), file_path(fp) {
660  read_file();
661  init();
662  };
boost::filesystem::path file_path
Definition: Importer.h:701
+ Here is the call graph for this function:

Member Function Documentation

◆ detect_column_types()

std::vector< SQLTypes > import_export::Detector::detect_column_types ( const std::vector< std::string > &  row)
private

Definition at line 3085 of file Importer.cpp.

3085  {
3086  std::vector<SQLTypes> types(row.size());
3087  for (size_t i = 0; i < row.size(); i++) {
3088  types[i] = detect_sqltype(row[i]);
3089  }
3090  return types;
3091 }
static SQLTypes detect_sqltype(const std::string &str)
Definition: Importer.cpp:2991

◆ detect_headers()

bool import_export::Detector::detect_headers ( const std::vector< SQLTypes > &  first_types,
const std::vector< SQLTypes > &  rest_types 
)
private

Definition at line 3227 of file Importer.cpp.

References kTEXT.

3228  {
3229  if (head_types.size() != tail_types.size()) {
3230  return false;
3231  }
3232  bool has_headers = false;
3233  for (size_t col_idx = 0; col_idx < tail_types.size(); col_idx++) {
3234  if (head_types[col_idx] != kTEXT) {
3235  return false;
3236  }
3237  has_headers = has_headers || tail_types[col_idx] != kTEXT;
3238  }
3239  return has_headers;
3240 }
Definition: sqltypes.h:54

◆ detect_row_delimiter()

void import_export::Detector::detect_row_delimiter ( )
private

Definition at line 2933 of file Importer.cpp.

References import_export::DataStreamSink::copy_params, import_export::CopyParams::delimiter, and import_export::DataStreamSink::file_path.

2933  {
2934  if (copy_params.delimiter == '\0') {
2935  copy_params.delimiter = ',';
2936  if (boost::filesystem::extension(file_path) == ".tsv") {
2937  copy_params.delimiter = '\t';
2938  }
2939  }
2940 }
boost::filesystem::path file_path
Definition: Importer.h:701

◆ detect_sqltype()

SQLTypes import_export::Detector::detect_sqltype ( const std::string &  str)
static

Definition at line 2991 of file Importer.cpp.

References kBIGINT, kDATE, kDOUBLE, kFLOAT, kINT, kLINESTRING, kMULTIPOLYGON, kPOINT, kPOLYGON, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, import_export::try_strptimes(), and run_benchmark_import::type.

2991  {
2992  SQLTypes type = kTEXT;
2993  if (try_cast<double>(str)) {
2994  type = kDOUBLE;
2995  /*if (try_cast<bool>(str)) {
2996  type = kBOOLEAN;
2997  }*/
2998  if (try_cast<int16_t>(str)) {
2999  type = kSMALLINT;
3000  } else if (try_cast<int32_t>(str)) {
3001  type = kINT;
3002  } else if (try_cast<int64_t>(str)) {
3003  type = kBIGINT;
3004  } else if (try_cast<float>(str)) {
3005  type = kFLOAT;
3006  }
3007  }
3008 
3009  // check for geo types
3010  if (type == kTEXT) {
3011  // convert to upper case
3012  std::string str_upper_case = str;
3013  std::transform(
3014  str_upper_case.begin(), str_upper_case.end(), str_upper_case.begin(), ::toupper);
3015 
3016  // then test for leading words
3017  if (str_upper_case.find("POINT") == 0) {
3018  type = kPOINT;
3019  } else if (str_upper_case.find("LINESTRING") == 0) {
3020  type = kLINESTRING;
3021  } else if (str_upper_case.find("POLYGON") == 0) {
3023  type = kMULTIPOLYGON;
3024  } else {
3025  type = kPOLYGON;
3026  }
3027  } else if (str_upper_case.find("MULTIPOLYGON") == 0) {
3028  type = kMULTIPOLYGON;
3029  } else if (str_upper_case.find_first_not_of("0123456789ABCDEF") ==
3030  std::string::npos &&
3031  (str_upper_case.size() % 2) == 0) {
3032  // simple hex blob (two characters per byte, not uu-encode or base64)
3033  if (str_upper_case.size() >= 10) {
3034  // match WKB blobs for supported geometry types
3035  // the first byte specifies if the data is big-endian or little-endian
3036  // the next four bytes are the geometry type (1 = POINT etc.)
3037  // @TODO support eWKB, which has extra bits set in the geometry type
3038  auto first_five_bytes = str_upper_case.substr(0, 10);
3039  if (first_five_bytes == "0000000001" || first_five_bytes == "0101000000") {
3040  type = kPOINT;
3041  } else if (first_five_bytes == "0000000002" || first_five_bytes == "0102000000") {
3042  type = kLINESTRING;
3043  } else if (first_five_bytes == "0000000003" || first_five_bytes == "0103000000") {
3044  type = kPOLYGON;
3045  } else if (first_five_bytes == "0000000006" || first_five_bytes == "0106000000") {
3046  type = kMULTIPOLYGON;
3047  } else {
3048  // unsupported WKB type
3049  return type;
3050  }
3051  } else {
3052  // too short to be WKB
3053  return type;
3054  }
3055  }
3056  }
3057 
3058  // check for time types
3059  if (type == kTEXT) {
3060  // @TODO
3061  // make these tests more robust so they don't match stuff they should not
3062  char* buf;
3063  buf = try_strptimes(str.c_str(),
3064  {"%Y-%m-%d", "%m/%d/%Y", "%Y/%m/%d", "%d-%b-%y", "%d/%b/%Y"});
3065  if (buf) {
3066  type = kDATE;
3067  if (*buf == 'T' || *buf == ' ' || *buf == ':') {
3068  buf++;
3069  }
3070  }
3071  buf = try_strptimes(buf == nullptr ? str.c_str() : buf,
3072  {"%T %z", "%T", "%H%M%S", "%R"});
3073  if (buf) {
3074  if (type == kDATE) {
3075  type = kTIMESTAMP;
3076  } else {
3077  type = kTIME;
3078  }
3079  }
3080  }
3081 
3082  return type;
3083 }
char * try_strptimes(const char *str, const std::vector< std::string > &formats)
Definition: Importer.cpp:2979
Definition: sqltypes.h:51
SQLTypes
Definition: sqltypes.h:40
static constexpr bool PROMOTE_POLYGON_TO_MULTIPOLYGON
Definition: Importer.cpp:145
Definition: sqltypes.h:54
Definition: sqltypes.h:55
Definition: sqltypes.h:47
+ Here is the call graph for this function:

◆ find_best_encodings()

std::vector< EncodingType > import_export::Detector::find_best_encodings ( const std::vector< std::vector< std::string >>::const_iterator &  row_begin,
const std::vector< std::vector< std::string >>::const_iterator &  row_end,
const std::vector< SQLTypes > &  best_types 
)
private

Definition at line 3191 of file Importer.cpp.

References import_export::DataStreamSink::file_path, IS_STRING, kENCODING_DICT, and kENCODING_NONE.

3194  {
3195  if (raw_rows.size() < 1) {
3196  throw std::runtime_error("No rows found in: " +
3197  boost::filesystem::basename(file_path));
3198  }
3199  size_t num_cols = best_types.size();
3200  std::vector<EncodingType> best_encodes(num_cols, kENCODING_NONE);
3201  std::vector<size_t> num_rows_per_col(num_cols, 1);
3202  std::vector<std::unordered_set<std::string>> count_set(num_cols);
3203  for (auto row = row_begin; row != row_end; row++) {
3204  for (size_t col_idx = 0; col_idx < row->size() && col_idx < num_cols; col_idx++) {
3205  if (IS_STRING(best_types[col_idx])) {
3206  count_set[col_idx].insert(row->at(col_idx));
3207  num_rows_per_col[col_idx]++;
3208  }
3209  }
3210  }
3211  for (size_t col_idx = 0; col_idx < num_cols; col_idx++) {
3212  if (IS_STRING(best_types[col_idx])) {
3213  float uniqueRatio =
3214  static_cast<float>(count_set[col_idx].size()) / num_rows_per_col[col_idx];
3215  if (uniqueRatio < 0.75) {
3216  best_encodes[col_idx] = kENCODING_DICT;
3217  }
3218  }
3219  }
3220  return best_encodes;
3221 }
std::vector< std::vector< std::string > > raw_rows
Definition: Importer.h:668
boost::filesystem::path file_path
Definition: Importer.h:701
#define IS_STRING(T)
Definition: sqltypes.h:173

◆ find_best_sqltypes() [1/3]

void import_export::Detector::find_best_sqltypes ( )
private

Definition at line 3138 of file Importer.cpp.

References import_export::DataStreamSink::copy_params.

3138  {
3140 }
std::vector< SQLTypes > best_sqltypes
Definition: Importer.h:670
std::vector< std::vector< std::string > > raw_rows
Definition: Importer.h:668

◆ find_best_sqltypes() [2/3]

std::vector< SQLTypes > import_export::Detector::find_best_sqltypes ( const std::vector< std::vector< std::string >> &  raw_rows,
const CopyParams copy_params 
)
private

Definition at line 3142 of file Importer.cpp.

References import_export::DataStreamSink::copy_params.

3144  {
3145  return find_best_sqltypes(raw_rows.begin(), raw_rows.end(), copy_params);
3146 }
std::vector< std::vector< std::string > > raw_rows
Definition: Importer.h:668

◆ find_best_sqltypes() [3/3]

std::vector< SQLTypes > import_export::Detector::find_best_sqltypes ( const std::vector< std::vector< std::string >>::const_iterator &  row_begin,
const std::vector< std::vector< std::string >>::const_iterator &  row_end,
const CopyParams copy_params 
)
private

Definition at line 3148 of file Importer.cpp.

References run_benchmark_import::end_time, import_export::DataStreamSink::file_path, kCHAR, kTEXT, and import_export::CopyParams::null_str.

3151  {
3152  if (raw_rows.size() < 1) {
3153  throw std::runtime_error("No rows found in: " +
3154  boost::filesystem::basename(file_path));
3155  }
3156  auto end_time = std::chrono::steady_clock::now() + timeout;
3157  size_t num_cols = raw_rows.front().size();
3158  std::vector<SQLTypes> best_types(num_cols, kCHAR);
3159  std::vector<size_t> non_null_col_counts(num_cols, 0);
3160  for (auto row = row_begin; row != row_end; row++) {
3161  while (best_types.size() < row->size() || non_null_col_counts.size() < row->size()) {
3162  best_types.push_back(kCHAR);
3163  non_null_col_counts.push_back(0);
3164  }
3165  for (size_t col_idx = 0; col_idx < row->size(); col_idx++) {
3166  // do not count nulls
3167  if (row->at(col_idx) == "" || !row->at(col_idx).compare(copy_params.null_str)) {
3168  continue;
3169  }
3170  SQLTypes t = detect_sqltype(row->at(col_idx));
3171  non_null_col_counts[col_idx]++;
3172  if (!more_restrictive_sqltype(best_types[col_idx], t)) {
3173  best_types[col_idx] = t;
3174  }
3175  }
3176  if (std::chrono::steady_clock::now() > end_time) {
3177  break;
3178  }
3179  }
3180  for (size_t col_idx = 0; col_idx < num_cols; col_idx++) {
3181  // if we don't have any non-null values for this column make it text to be
3182  // safe b/c that is least restrictive type
3183  if (non_null_col_counts[col_idx] == 0) {
3184  best_types[col_idx] = kTEXT;
3185  }
3186  }
3187 
3188  return best_types;
3189 }
SQLTypes
Definition: sqltypes.h:40
static SQLTypes detect_sqltype(const std::string &str)
Definition: Importer.cpp:2991
std::vector< std::vector< std::string > > raw_rows
Definition: Importer.h:668
boost::filesystem::path file_path
Definition: Importer.h:701
Definition: sqltypes.h:54
static bool more_restrictive_sqltype(const SQLTypes a, const SQLTypes b)
Definition: Importer.cpp:3093
std::chrono::duration< double > timeout
Definition: Importer.h:702
Definition: sqltypes.h:43

◆ find_best_sqltypes_and_headers()

void import_export::Detector::find_best_sqltypes_and_headers ( )
private

Definition at line 3115 of file Importer.cpp.

References import_export::AUTODETECT, import_export::DataStreamSink::copy_params, import_export::HAS_HEADER, import_export::CopyParams::has_header, and import_export::NO_HEADER.

3115  {
3117  best_encodings =
3118  find_best_encodings(raw_rows.begin() + 1, raw_rows.end(), best_sqltypes);
3119  std::vector<SQLTypes> head_types = detect_column_types(raw_rows.at(0));
3120  switch (copy_params.has_header) {
3122  has_headers = detect_headers(head_types, best_sqltypes);
3123  if (has_headers) {
3125  } else {
3127  }
3128  break;
3130  has_headers = false;
3131  break;
3133  has_headers = true;
3134  break;
3135  }
3136 }
std::vector< SQLTypes > best_sqltypes
Definition: Importer.h:670
ImportHeaderRow has_header
Definition: CopyParams.h:48
std::vector< EncodingType > find_best_encodings(const std::vector< std::vector< std::string >>::const_iterator &row_begin, const std::vector< std::vector< std::string >>::const_iterator &row_end, const std::vector< SQLTypes > &best_types)
Definition: Importer.cpp:3191
std::vector< std::vector< std::string > > raw_rows
Definition: Importer.h:668
std::vector< EncodingType > best_encodings
Definition: Importer.h:671
bool detect_headers(const std::vector< SQLTypes > &first_types, const std::vector< SQLTypes > &rest_types)
Definition: Importer.cpp:3227
std::vector< SQLTypes > detect_column_types(const std::vector< std::string > &row)
Definition: Importer.cpp:3085

◆ get_headers()

std::vector< std::string > import_export::Detector::get_headers ( )

Definition at line 3250 of file Importer.cpp.

References to_string().

Referenced by DBHandler::detect_column_types().

3250  {
3251  std::vector<std::string> headers(best_sqltypes.size());
3252  for (size_t i = 0; i < best_sqltypes.size(); i++) {
3253  if (has_headers && i < raw_rows[0].size()) {
3254  headers[i] = raw_rows[0][i];
3255  } else {
3256  headers[i] = "column_" + std::to_string(i + 1);
3257  }
3258  }
3259  return headers;
3260 }
std::vector< SQLTypes > best_sqltypes
Definition: Importer.h:670
std::string to_string(char const *&&v)
std::vector< std::vector< std::string > > raw_rows
Definition: Importer.h:668
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ get_sample_rows()

std::vector< std::vector< std::string > > import_export::Detector::get_sample_rows ( size_t  n)

Definition at line 3242 of file Importer.cpp.

Referenced by DBHandler::detect_column_types().

3242  {
3243  n = std::min(n, raw_rows.size());
3244  size_t offset = (has_headers && raw_rows.size() > 1) ? 1 : 0;
3245  std::vector<std::vector<std::string>> sample_rows(raw_rows.begin() + offset,
3246  raw_rows.begin() + n);
3247  return sample_rows;
3248 }
std::vector< std::vector< std::string > > raw_rows
Definition: Importer.h:668
+ Here is the caller graph for this function:

◆ importDelimited()

ImportStatus import_export::Detector::importDelimited ( const std::string &  file_path,
const bool  decompressed 
)
overrideprivatevirtual

Implements import_export::DataStreamSink.

Definition at line 2866 of file Importer.cpp.

References import_export::DataStreamSink::copy_params, run_benchmark_import::end_time, import_export::DataStreamSink::import_status, import_export::CopyParams::line_delim, import_export::DataStreamSink::load_failed, import_export::ImportStatus::load_truncated, import_export::DataStreamSink::p_file, and import_export::ImportStatus::rows_completed.

2867  {
2868  if (!p_file) {
2869  p_file = fopen(file_path.c_str(), "rb");
2870  }
2871  if (!p_file) {
2872  throw std::runtime_error("failed to open file '" + file_path +
2873  "': " + strerror(errno));
2874  }
2875 
2876  // somehow clang does not support ext/stdio_filebuf.h, so
2877  // need to diy readline with customized copy_params.line_delim...
2878  std::string line;
2879  line.reserve(1 * 1024 * 1024);
2880  auto end_time = std::chrono::steady_clock::now() +
2881  timeout * (boost::istarts_with(file_path, "s3://") ? 3 : 1);
2882  try {
2883  while (!feof(p_file)) {
2884  int c;
2885  size_t n = 0;
2886  while (EOF != (c = fgetc(p_file)) && copy_params.line_delim != c) {
2887  if (n++ >= line.capacity()) {
2888  break;
2889  }
2890  line += c;
2891  }
2892  if (0 == n) {
2893  break;
2894  }
2895  // remember the first line, which is possibly a header line, to
2896  // ignore identical header line(s) in 2nd+ files of a archive;
2897  // otherwise, 2nd+ header may be mistaken as an all-string row
2898  // and so be final column types.
2899  if (line1.empty()) {
2900  line1 = line;
2901  } else if (line == line1) {
2902  line.clear();
2903  continue;
2904  }
2905 
2906  raw_data += line;
2908  line.clear();
2910  if (std::chrono::steady_clock::now() > end_time) {
2911  if (import_status.rows_completed > 10000) {
2912  break;
2913  }
2914  }
2915  }
2916  } catch (std::exception& e) {
2917  }
2918 
2919  // as if load truncated
2921  load_failed = true;
2922 
2923  fclose(p_file);
2924  p_file = nullptr;
2925  return import_status;
2926 }
boost::filesystem::path file_path
Definition: Importer.h:701
std::chrono::duration< double > timeout
Definition: Importer.h:702
std::string raw_data
Definition: Importer.h:700

◆ init()

void import_export::Detector::init ( )
private

Definition at line 2860 of file Importer.cpp.

2860  {
2862  split_raw_data();
2864 }
void find_best_sqltypes_and_headers()
Definition: Importer.cpp:3115

◆ more_restrictive_sqltype()

bool import_export::Detector::more_restrictive_sqltype ( const SQLTypes  a,
const SQLTypes  b 
)
staticprivate

Definition at line 3093 of file Importer.cpp.

References kBIGINT, kBOOLEAN, kCHAR, kDATE, kDOUBLE, kFLOAT, kINT, kLINESTRING, kMULTIPOLYGON, kPOINT, kPOLYGON, kSMALLINT, kTEXT, kTIME, and kTIMESTAMP.

3093  {
3094  static std::array<int, kSQLTYPE_LAST> typeorder;
3095  typeorder[kCHAR] = 0;
3096  typeorder[kBOOLEAN] = 2;
3097  typeorder[kSMALLINT] = 3;
3098  typeorder[kINT] = 4;
3099  typeorder[kBIGINT] = 5;
3100  typeorder[kFLOAT] = 6;
3101  typeorder[kDOUBLE] = 7;
3102  typeorder[kTIMESTAMP] = 8;
3103  typeorder[kTIME] = 9;
3104  typeorder[kDATE] = 10;
3105  typeorder[kPOINT] = 11;
3106  typeorder[kLINESTRING] = 11;
3107  typeorder[kPOLYGON] = 11;
3108  typeorder[kMULTIPOLYGON] = 11;
3109  typeorder[kTEXT] = 12;
3110 
3111  // note: b < a instead of a < b because the map is ordered most to least restrictive
3112  return typeorder[b] < typeorder[a];
3113 }
Definition: sqltypes.h:51
Definition: sqltypes.h:54
Definition: sqltypes.h:55
Definition: sqltypes.h:43
Definition: sqltypes.h:47

◆ read_file()

void import_export::Detector::read_file ( )
private

Definition at line 2928 of file Importer.cpp.

References import_export::DataStreamSink::archivePlumber().

2928  {
2929  // this becomes analogous to Importer::import()
2931 }
+ Here is the call graph for this function:

◆ split_raw_data()

void import_export::Detector::split_raw_data ( )
private

Definition at line 2942 of file Importer.cpp.

References import_export::DataStreamSink::copy_params, import_export::delimited_parser::get_row(), and import_export::CopyParams::threads.

2942  {
2943  const char* buf = raw_data.c_str();
2944  const char* buf_end = buf + raw_data.size();
2945  bool try_single_thread = false;
2946  for (const char* p = buf; p < buf_end; p++) {
2947  std::vector<std::string> row;
2948  std::vector<std::unique_ptr<char[]>> tmp_buffers;
2950  p, buf_end, buf_end, copy_params, nullptr, row, tmp_buffers, try_single_thread);
2951  raw_rows.push_back(row);
2952  if (try_single_thread) {
2953  break;
2954  }
2955  }
2956  if (try_single_thread) {
2957  copy_params.threads = 1;
2958  raw_rows.clear();
2959  for (const char* p = buf; p < buf_end; p++) {
2960  std::vector<std::string> row;
2961  std::vector<std::unique_ptr<char[]>> tmp_buffers;
2963  p, buf_end, buf_end, copy_params, nullptr, row, tmp_buffers, try_single_thread);
2964  raw_rows.push_back(row);
2965  }
2966  }
2967 }
std::vector< std::vector< std::string > > raw_rows
Definition: Importer.h:668
std::string raw_data
Definition: Importer.h:700
const char * get_row(const char *buf, const char *buf_end, const char *entire_buf_end, const import_export::CopyParams &copy_params, const bool *is_array, std::vector< T > &row, std::vector< std::unique_ptr< char[]>> &tmp_buffers, bool &try_single_thread)
Parses the first row in the given buffer and inserts fields into given vector.
+ Here is the call graph for this function:

Member Data Documentation

◆ best_encodings

std::vector<EncodingType> import_export::Detector::best_encodings

Definition at line 671 of file Importer.h.

Referenced by DBHandler::detect_column_types().

◆ best_sqltypes

std::vector<SQLTypes> import_export::Detector::best_sqltypes

Definition at line 670 of file Importer.h.

Referenced by DBHandler::detect_column_types().

◆ file_path

boost::filesystem::path import_export::Detector::file_path
private

Definition at line 701 of file Importer.h.

◆ has_headers

bool import_export::Detector::has_headers = false

Definition at line 672 of file Importer.h.

◆ line1

std::string import_export::Detector::line1
private

Definition at line 703 of file Importer.h.

◆ raw_data

std::string import_export::Detector::raw_data
private

Definition at line 700 of file Importer.h.

◆ raw_rows

std::vector<std::vector<std::string> > import_export::Detector::raw_rows

Definition at line 668 of file Importer.h.

◆ timeout

std::chrono::duration<double> import_export::Detector::timeout {1}
private

Definition at line 702 of file Importer.h.


The documentation for this class was generated from the following files: