bool
PluginAsyncSurrogate::Init(NPMIMEType aPluginType, NPP aInstance, uint16_t aMode,
int16_t aArgc, char* aArgn[], char* aArgv[])
{
mMimeType = aPluginType;
mInstance = aInstance;
mMode = aMode;
for (int i = 0; i < aArgc; ++i) {
mNames.AppendElement(NullableString(aArgn[i]));
mValues.AppendElement(NullableString(aArgv[i]));
}
return true;
}
PluginAsyncSurrogate::PendingNewStreamCall::PendingNewStreamCall(
NPMIMEType aType, NPStream* aStream, NPBool aSeekable)
: mType(NullableString(aType))
, mStream(aStream)
, mSeekable(aSeekable)
{
}
virtual void processRow() {
if (into.rows.size() == max_rows) {
into.more_rows = true;
into.__isset.more_rows = true;
return;
}
into.rows.resize(into.rows.size() + 1);
vector<NullableString> &row(into.rows.back());
row.reserve(fields.size());
BOOST_FOREACH(GeneralField::Ptr g, fields) {
NullableString ns;
if (g->isNull()) {
row.push_back(NullableString());
} else {
row.push_back(NullableString(g->val().valString()));
}
}
// Reads an integer or a float from ptr based on the type and the byte width.
TargetValue ResultSet::makeTargetValue(const int8_t* ptr,
const int8_t compact_sz,
const TargetInfo& target_info,
const size_t target_logical_idx,
const bool translate_strings,
const bool decimal_to_double,
const size_t entry_buff_idx) const {
const bool float_argument_input = takes_float_argument(target_info);
const auto actual_compact_sz = float_argument_input ? sizeof(float) : compact_sz;
auto ival = read_int_from_buff(ptr, actual_compact_sz);
const auto& chosen_type = get_compact_type(target_info);
if (!lazy_fetch_info_.empty()) {
CHECK_LT(target_logical_idx, lazy_fetch_info_.size());
const auto& col_lazy_fetch = lazy_fetch_info_[target_logical_idx];
if (col_lazy_fetch.is_lazily_fetched) {
const auto storage_idx = getStorageIndex(entry_buff_idx);
CHECK_LT(static_cast<size_t>(storage_idx.first), col_buffers_.size());
auto& frag_col_buffers = getColumnFrag(storage_idx.first, target_logical_idx, ival);
ival = lazy_decode(col_lazy_fetch, frag_col_buffers[col_lazy_fetch.local_col_id], ival);
if (chosen_type.is_fp()) {
const auto dval = *reinterpret_cast<const double*>(may_alias_ptr(&ival));
if (chosen_type.get_type() == kFLOAT) {
return ScalarTargetValue(static_cast<float>(dval));
} else {
return ScalarTargetValue(dval);
}
}
}
}
if (chosen_type.is_fp()) {
switch (actual_compact_sz) {
case 8: {
const auto dval = *reinterpret_cast<const double*>(ptr);
return chosen_type.get_type() == kFLOAT ? ScalarTargetValue(static_cast<const float>(dval))
: ScalarTargetValue(dval);
}
case 4: {
CHECK_EQ(kFLOAT, chosen_type.get_type());
return *reinterpret_cast<const float*>(ptr);
}
default:
CHECK(false);
}
}
if (chosen_type.is_integer() | chosen_type.is_boolean() || chosen_type.is_time() || chosen_type.is_timeinterval()) {
if (is_distinct_target(target_info)) {
return TargetValue(
count_distinct_set_size(ival, target_logical_idx, query_mem_desc_.count_distinct_descriptors_));
}
// TODO(alex): remove int_resize_cast, make read_int_from_buff return the right type instead
if (inline_int_null_val(chosen_type) == int_resize_cast(ival, chosen_type.get_logical_size())) {
return inline_int_null_val(target_info.sql_type);
}
return ival;
}
if (chosen_type.is_string() && chosen_type.get_compression() == kENCODING_DICT) {
if (translate_strings) {
if (static_cast<int32_t>(ival) == NULL_INT) { // TODO(alex): this isn't nice, fix it
return NullableString(nullptr);
}
StringDictionaryProxy* sdp{nullptr};
if (!chosen_type.get_comp_param()) {
sdp = row_set_mem_owner_->getLiteralStringDictProxy();
} else {
sdp = executor_ ? executor_->getStringDictionaryProxy(chosen_type.get_comp_param(), row_set_mem_owner_, false)
: row_set_mem_owner_->getStringDictProxy(chosen_type.get_comp_param());
}
return NullableString(sdp->getString(ival));
} else {
return static_cast<int64_t>(static_cast<int32_t>(ival));
}
}
if (chosen_type.is_decimal()) {
if (decimal_to_double) {
if (ival == inline_int_null_val(SQLTypeInfo(decimal_to_int_type(chosen_type), false))) {
return NULL_DOUBLE;
}
return static_cast<double>(ival) / exp_to_scale(chosen_type.get_scale());
}
return ival;
}
CHECK(false);
return TargetValue(int64_t(0));
}
