Classes
struct	DataBufferBase

struct	DataBuffer

struct	ArrowValueBase

struct	ArrowValue

struct	ArrowValue< void * >

struct	ArrowValue< bool >

struct	ArrowValue< float >

struct	ArrowValue< double >

struct	ArrowValue< int64_t >

struct	ArrowValue< std::string >

struct	ArrowValue< arrow::Decimal128 >

Typedefs
using	VarValue = boost::variant< bool, float, double, int64_t, std::string, void *, arrow::Decimal128 >

template<typename T >
using	enable_if_integral = typename std::enable_if_t< std::is_integral< T >::value, T >

template<typename T >
using	enable_if_integral_not_bool = typename std::enable_if_t< std::is_integral< T >::value &&!std::is_same< T, bool >::value, T >

template<typename T >
using	enable_if_floating = typename std::enable_if_t< std::is_floating_point< T >::value, T >

Functions
std::string	error_context (const ColumnDescriptor cd, import_export::BadRowsTracker const bad_rows_tracker)

template<typename SrcType , typename DstType >
VarValue	get_numeric_value (const arrow::Array &array, const int64_t idx)

template<typename SrcType >
VarValue	get_string_value (const arrow::Array &array, const int64_t idx)

auto	value_getter (const arrow::Array &array, const ColumnDescriptor cd, import_export::BadRowsTracker const bad_rows_tracker)

void	type_conversion_error (const std::string pt, const ColumnDescriptor cd, import_export::BadRowsTracker const bad_rows_tracker)

template<typename DATA_TYPE , typename VALUE_TYPE >
void	data_conversion_error (const VALUE_TYPE v, const ColumnDescriptor cd, import_export::BadRowsTracker const bad_rows_tracker)

void	data_conversion_error (const std::string &v, const ColumnDescriptor cd, import_export::BadRowsTracker const bad_rows_tracker)

template<typename DATA_TYPE >
auto &	operator<< (DataBuffer< DATA_TYPE > &data, const VarValue &var)

Variables
constexpr int64_t	kMillisecondsInSecond = 1000LL

constexpr int64_t	kMicrosecondsInSecond = 1000LL * 1000LL

constexpr int64_t	kNanosecondsinSecond = 1000LL * 1000LL * 1000LL

constexpr int32_t	kSecondsInDay = 86400

static const std::map < std::pair< int32_t, arrow::TimeUnit::type > , std::pair< SQLOps, int64_t > >	_precision_scale_lookup

Typedef Documentation

template<typename T >

using anonymous_namespace{ArrowImporter.h}::enable_if_floating = typedef typename std::enable_if_t<std::is_floating_point<T>::value, T>

Definition at line 73 of file ArrowImporter.h.

template<typename T >

using anonymous_namespace{ArrowImporter.h}::enable_if_integral = typedef typename std::enable_if_t<std::is_integral<T>::value, T>

Definition at line 67 of file ArrowImporter.h.

template<typename T >

using anonymous_namespace{ArrowImporter.h}::enable_if_integral_not_bool = typedef typename std::enable_if_t<std::is_integral<T>::value && !std::is_same<T, bool>::value, T>

Definition at line 71 of file ArrowImporter.h.

using anonymous_namespace{ArrowImporter.h}::VarValue = typedef boost::variant<bool, float, double, int64_t, std::string, void*, arrow::Decimal128>

Definition at line 64 of file ArrowImporter.h.

Function Documentation

template<typename DATA_TYPE , typename VALUE_TYPE >

void anonymous_namespace{ArrowImporter.h}::data_conversion_error	(	const VALUE_TYPE	v,
		const ColumnDescriptor *	cd,
		import_export::BadRowsTracker *const	bad_rows_tracker
	)

inline

Definition at line 145 of file ArrowImporter.h.

References arrow_throw_if(), error_context(), and to_string().

Referenced by anonymous_namespace{ArrowImporter.h}::ArrowValue< std::string >::operator DATA_TYPE().

                                                                                        {
   arrow_throw_if(true,
                  error_context(cd, bad_rows_tracker) +
                      "Invalid data conversion from parquet value " + std::to_string(v) +
                      " to " + std::to_string(DATA_TYPE(v)));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{ArrowImporter.h}::data_conversion_error	(	const std::string &	v,
		const ColumnDescriptor *	cd,
		import_export::BadRowsTracker *const	bad_rows_tracker
	)

inline

Definition at line 154 of file ArrowImporter.h.

References arrow_throw_if(), ColumnDescriptor::columnType, error_context(), and SQLTypeInfo::get_type_name().

                                                                                        {
   arrow_throw_if(true,
                  error_context(cd, bad_rows_tracker) +
                      "Invalid data conversion from parquet string '" + v + "' to " +
                      cd->columnType.get_type_name() + " column type");
 }

Here is the call graph for this function:

std::string anonymous_namespace{ArrowImporter.h}::error_context	(	const ColumnDescriptor *	cd,
		import_export::BadRowsTracker *const	bad_rows_tracker
	)

inline

Definition at line 77 of file ArrowImporter.h.

References ColumnDescriptor::columnName, import_export::BadRowsTracker::file_name, import_export::BadRowsTracker::row_group, and to_string().

Referenced by anonymous_namespace{ArrowImporter.h}::ArrowValue< arrow::Decimal128 >::ArrowValue(), import_export::TypedImportBuffer::convert_arrow_val_to_import_buffer(), data_conversion_error(), type_conversion_error(), and value_getter().

                                                                                       {
   return bad_rows_tracker ? "File " + bad_rows_tracker->file_name + ", row-group " +
                                 std::to_string(bad_rows_tracker->row_group) +
                                 (cd ? ", column " + cd->columnName + ": " : "")
                           : std::string();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename SrcType , typename DstType >

VarValue anonymous_namespace{ArrowImporter.h}::get_numeric_value	(	const arrow::Array &	array,
		const int64_t	idx
	)

inline

Definition at line 86 of file ArrowImporter.h.

                                                                               {
   using ArrayType = typename arrow::TypeTraits<SrcType>::ArrayType;
   return (DstType) static_cast<const ArrayType&>(array).Value(idx);
 }

template<typename SrcType >

VarValue anonymous_namespace{ArrowImporter.h}::get_string_value	(	const arrow::Array &	array,
		const int64_t	idx
	)

inline

Definition at line 92 of file ArrowImporter.h.

                                                                              {
   using ArrayType = typename arrow::TypeTraits<SrcType>::ArrayType;
   return static_cast<const ArrayType&>(array).GetString(idx);
 }

template<typename DATA_TYPE >

auto& anonymous_namespace{ArrowImporter.h}::operator<<	(	DataBuffer< DATA_TYPE > &	data,
		const VarValue &	var
	)

inline

Definition at line 500 of file ArrowImporter.h.

References exprtype.

                                                                           {
   boost::apply_visitor(
       [&data](const auto& v) {
         data.buffer.push_back(DATA_TYPE(ArrowValue<exprtype(v)>(data, v)));
       },
       var);
   return data;
 }

void anonymous_namespace{ArrowImporter.h}::type_conversion_error	(	const std::string	pt,
		const ColumnDescriptor *	cd,
		import_export::BadRowsTracker *const	bad_rows_tracker
	)

inline

Definition at line 135 of file ArrowImporter.h.

References arrow_throw_if(), ColumnDescriptor::columnType, error_context(), and SQLTypeInfo::get_type_name().

Referenced by anonymous_namespace{ArrowImporter.h}::ArrowValue< bool >::operator DATA_TYPE().

                                                                                        {
   arrow_throw_if(true,
                  error_context(cd, bad_rows_tracker) +
                      "Invalid type conversion from parquet " + pt + " type to " +
                      cd->columnType.get_type_name());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

auto anonymous_namespace{ArrowImporter.h}::value_getter	(	const arrow::Array &	array,
		const ColumnDescriptor *	cd,
		import_export::BadRowsTracker *const	bad_rows_tracker
	)

inline

Definition at line 104 of file ArrowImporter.h.

References arrow_throw_if(), error_context(), NUMERIC_CASE, heavydb.dtypes::STRING, and STRING_CASE.

Referenced by import_export::TypedImportBuffer::convert_arrow_val_to_import_buffer().

                                                                               {
   switch (array.type_id()) {
     NUMERIC_CASE(BOOL, arrow::BooleanType, bool)
     NUMERIC_CASE(UINT8, arrow::UInt8Type, int64_t)
     NUMERIC_CASE(UINT16, arrow::UInt16Type, int64_t)
     NUMERIC_CASE(UINT32, arrow::UInt32Type, int64_t)
     NUMERIC_CASE(UINT64, arrow::Int64Type, int64_t)
     NUMERIC_CASE(INT8, arrow::Int8Type, int64_t)
     NUMERIC_CASE(INT16, arrow::Int16Type, int64_t)
     NUMERIC_CASE(INT32, arrow::Int32Type, int64_t)
     NUMERIC_CASE(INT64, arrow::Int64Type, int64_t)
     NUMERIC_CASE(FLOAT, arrow::FloatType, float)
     NUMERIC_CASE(DOUBLE, arrow::DoubleType, double)
     NUMERIC_CASE(DATE32, arrow::Date32Type, int64_t)
     NUMERIC_CASE(DATE64, arrow::Date64Type, int64_t)
     NUMERIC_CASE(TIME64, arrow::Time64Type, int64_t)
     NUMERIC_CASE(TIME32, arrow::Time32Type, int64_t)
     NUMERIC_CASE(TIMESTAMP, arrow::TimestampType, int64_t)
     NUMERIC_CASE(DECIMAL, arrow::Decimal128Type, arrow::Decimal128)
     STRING_CASE(STRING, arrow::StringType)
     STRING_CASE(BINARY, arrow::BinaryType)
     default:
       arrow_throw_if(true,
                      error_context(cd, bad_rows_tracker) + "Parquet type " +
                          array.type()->name() + " is not supported");
       throw;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

const std::map<std::pair<int32_t, arrow::TimeUnit::type>, std::pair<SQLOps, int64_t> > anonymous_namespace{ArrowImporter.h}::_precision_scale_lookup

static

Initial value:

{
        {{0, arrow::TimeUnit::MILLI}, {kDIVIDE, kMillisecondsInSecond}},
        {{0, arrow::TimeUnit::MICRO}, {kDIVIDE, kMicrosecondsInSecond}},
        {{0, arrow::TimeUnit::NANO}, {kDIVIDE, kNanosecondsinSecond}},
        {{3, arrow::TimeUnit::SECOND}, {kMULTIPLY, kMicrosecondsInSecond}},
        {{3, arrow::TimeUnit::MICRO}, {kDIVIDE, kMillisecondsInSecond}},
        {{3, arrow::TimeUnit::NANO}, {kDIVIDE, kMicrosecondsInSecond}},
        {{6, arrow::TimeUnit::SECOND}, {kMULTIPLY, kMicrosecondsInSecond}},
        {{6, arrow::TimeUnit::MILLI}, {kMULTIPLY, kMillisecondsInSecond}},
        {{6, arrow::TimeUnit::NANO}, {kDIVIDE, kMillisecondsInSecond}},
        {{9, arrow::TimeUnit::SECOND}, {kMULTIPLY, kNanosecondsinSecond}},
        {{9, arrow::TimeUnit::MILLI}, {kMULTIPLY, kMicrosecondsInSecond}},
        {{9, arrow::TimeUnit::MICRO}, {kMULTIPLY, kMillisecondsInSecond}}}

Definition at line 212 of file ArrowImporter.h.

Referenced by anonymous_namespace{ArrowImporter.h}::ArrowValue< int64_t >::operator DATA_TYPE(), and anonymous_namespace{ArrowImporter.h}::ArrowValueBase< bool >::resolve_time().

constexpr int64_t anonymous_namespace{ArrowImporter.h}::kMicrosecondsInSecond = 1000LL * 1000LL

Definition at line 206 of file ArrowImporter.h.

constexpr int64_t anonymous_namespace{ArrowImporter.h}::kMillisecondsInSecond = 1000LL

Definition at line 205 of file ArrowImporter.h.

Referenced by anonymous_namespace{ArrowImporter.h}::ArrowValueBase< bool >::resolve_time().

constexpr int64_t anonymous_namespace{ArrowImporter.h}::kNanosecondsinSecond = 1000LL * 1000LL * 1000LL

Definition at line 207 of file ArrowImporter.h.

constexpr int32_t anonymous_namespace{ArrowImporter.h}::kSecondsInDay = 86400

Definition at line 208 of file ArrowImporter.h.

Referenced by anonymous_namespace{ArrowImporter.h}::ArrowValueBase< bool >::resolve_time().

Classes

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation