void ResourceHandleManager::dispatchSynchronousJob(ResourceHandle* job)
{
KURL kurl = job->request().url();
if (kurl.protocolIs("data")) {
parseDataUrl(job);
return;
}
ResourceHandleInternal* handle = job->getInternal();
#if LIBCURL_VERSION_NUM > 0x071200
// If defersLoading is true and we call curl_easy_perform
// on a paused handle, libcURL would do the transfert anyway
// and we would assert so force defersLoading to be false.
handle->m_defersLoading = false;
#endif
initializeHandle(job);
// curl_easy_perform blocks until the transfert is finished.
CURLcode ret = curl_easy_perform(handle->m_handle);
if (ret != 0) {
ResourceError error(String(handle->m_url), ret, String(handle->m_url), String(curl_easy_strerror(ret)));
handle->client()->didFail(job, error);
}
curl_easy_cleanup(handle->m_handle);
}
void checkAggregationAvgGenericValueAccessor() {
const GenericType &type = GenericType::Instance(true);
initializeHandle(type);
EXPECT_TRUE(aggregation_handle_avg_->finalize(*aggregation_handle_avg_state_).isNull());
typename GenericType::cpptype sum;
SetDataType(0, &sum);
std::unique_ptr<ColumnVectorsValueAccessor> accessor(new ColumnVectorsValueAccessor());
accessor->addColumn(createColumnVectorGeneric<GenericType>(type, &sum));
std::unique_ptr<AggregationState> va_state(
aggregation_handle_avg_->accumulateValueAccessor(accessor.get(),
std::vector<attribute_id>(1, 0)));
// Test the state generated directly by accumulateValueAccessor(), and also
// test after merging back.
CheckAvgValue<typename OutputType::cpptype>(
static_cast<typename OutputType::cpptype>(sum) / kNumSamples,
*aggregation_handle_avg_,
*va_state);
aggregation_handle_avg_->mergeStates(*va_state, aggregation_handle_avg_state_.get());
CheckAvgValue<typename OutputType::cpptype>(
static_cast<typename OutputType::cpptype>(sum) / kNumSamples,
*aggregation_handle_avg_,
*aggregation_handle_avg_state_);
}
void checkAggregationAvgGenericColumnVector() {
const GenericType &type = GenericType::Instance(true);
initializeHandle(type);
EXPECT_TRUE(aggregation_handle_avg_->finalize(*aggregation_handle_avg_state_).isNull());
typename GenericType::cpptype sum;
SetDataType(0, &sum);
std::vector<std::unique_ptr<ColumnVector>> column_vectors;
column_vectors.emplace_back(createColumnVectorGeneric<GenericType>(type, &sum));
std::unique_ptr<AggregationState> cv_state(
aggregation_handle_avg_->accumulateColumnVectors(column_vectors));
// Test the state generated directly by accumulateColumnVectors(), and also
// test after merging back.
CheckAvgValue<typename OutputType::cpptype>(
static_cast<typename OutputType::cpptype>(sum) / kNumSamples,
*aggregation_handle_avg_,
*cv_state);
aggregation_handle_avg_->mergeStates(*cv_state, aggregation_handle_avg_state_.get());
CheckAvgValue<typename OutputType::cpptype>(
static_cast<typename OutputType::cpptype>(sum) / kNumSamples,
*aggregation_handle_avg_,
*aggregation_handle_avg_state_);
}
void checkAggregationAvgGeneric() {
const GenericType &type = GenericType::Instance(true);
initializeHandle(type);
EXPECT_TRUE(aggregation_handle_avg_->finalize(*aggregation_handle_avg_state_).isNull());
typename GenericType::cpptype val;
typename GenericType::cpptype sum;
SetDataType(0, &sum);
iterateHandle(aggregation_handle_avg_state_.get(), type.makeNullValue());
for (int i = 0; i < kNumSamples; ++i) {
if (type.getTypeID() == kInt || type.getTypeID() == kLong) {
SetDataType(i - 10, &val);
} else {
SetDataType(static_cast<float>(i - 10)/10, &val);
}
iterateHandle(aggregation_handle_avg_state_.get(), type.makeValue(&val));
sum += val;
}
iterateHandle(aggregation_handle_avg_state_.get(), type.makeNullValue());
CheckAvgValue<typename OutputType::cpptype>(static_cast<typename OutputType::cpptype>(sum) / kNumSamples,
*aggregation_handle_avg_,
*aggregation_handle_avg_state_);
// Test mergeStates().
std::unique_ptr<AggregationState> merge_state(
aggregation_handle_avg_->createInitialState());
aggregation_handle_avg_->mergeStates(*merge_state,
aggregation_handle_avg_state_.get());
iterateHandle(merge_state.get(), type.makeNullValue());
for (int i = 0; i < kNumSamples; ++i) {
if (type.getTypeID() == kInt || type.getTypeID() == kLong) {
SetDataType(i - 10, &val);
} else {
SetDataType(static_cast<float>(i - 10)/10, &val);
}
iterateHandle(merge_state.get(), type.makeValue(&val));
sum += val;
}
aggregation_handle_avg_->mergeStates(*merge_state,
aggregation_handle_avg_state_.get());
CheckAvgValue<typename OutputType::cpptype>(
static_cast<typename OutputType::cpptype>(sum) / (2 * kNumSamples),
*aggregation_handle_avg_,
*aggregation_handle_avg_state_);
}
TEST_F(AggregationHandleAvgDeathTest, WrongTypeTest) {
const Type &int_non_null_type = IntType::Instance(false);
const Type &long_type = LongType::Instance(true);
const Type &double_type = DoubleType::Instance(true);
const Type &float_type = FloatType::Instance(true);
const Type &char_type = CharType::Instance(true, 10);
const Type &varchar_type = VarCharType::Instance(true, 10);
initializeHandle(IntType::Instance(true));
int int_val = 0;
std::int64_t long_val = 0;
double double_val = 0;
float float_val = 0;
iterateHandle(aggregation_handle_avg_state_.get(), int_non_null_type.makeValue(&int_val));
EXPECT_DEATH(iterateHandle(aggregation_handle_avg_state_.get(), long_type.makeValue(&long_val)), "");
EXPECT_DEATH(iterateHandle(aggregation_handle_avg_state_.get(), double_type.makeValue(&double_val)), "");
EXPECT_DEATH(iterateHandle(aggregation_handle_avg_state_.get(), float_type.makeValue(&float_val)), "");
EXPECT_DEATH(iterateHandle(aggregation_handle_avg_state_.get(), char_type.makeValue("asdf", 5)), "");
EXPECT_DEATH(iterateHandle(aggregation_handle_avg_state_.get(), varchar_type.makeValue("asdf", 5)), "");
// Test mergeStates() with incorrectly typed handles.
std::unique_ptr<AggregationHandle> aggregation_handle_avg_double(
AggregateFunctionFactory::Get(AggregationID::kAvg).createHandle(
std::vector<const Type*>(1, &double_type)));
std::unique_ptr<AggregationState> aggregation_state_avg_merge_double(
aggregation_handle_avg_double->createInitialState());
static_cast<const AggregationHandleAvg&>(*aggregation_handle_avg_double).iterateUnaryInl(
static_cast<AggregationStateAvg*>(aggregation_state_avg_merge_double.get()),
double_type.makeValue(&double_val));
EXPECT_DEATH(aggregation_handle_avg_->mergeStates(*aggregation_state_avg_merge_double,
aggregation_handle_avg_state_.get()),
"");
std::unique_ptr<AggregationHandle> aggregation_handle_avg_float(
AggregateFunctionFactory::Get(AggregationID::kAvg).createHandle(
std::vector<const Type*>(1, &float_type)));
std::unique_ptr<AggregationState> aggregation_state_avg_merge_float(
aggregation_handle_avg_float->createInitialState());
static_cast<const AggregationHandleAvg&>(*aggregation_handle_avg_float).iterateUnaryInl(
static_cast<AggregationStateAvg*>(aggregation_state_avg_merge_float.get()),
float_type.makeValue(&float_val));
EXPECT_DEATH(aggregation_handle_avg_->mergeStates(*aggregation_state_avg_merge_float,
aggregation_handle_avg_state_.get()),
"");
}
void ResourceHandleManager::startJob(ResourceHandle* job)
{
KURL kurl = job->request().url();
if (kurl.protocolIs("data")) {
parseDataUrl(job);
return;
}
initializeHandle(job);
m_runningJobs++;
CURLMcode ret = curl_multi_add_handle(m_curlMultiHandle, job->getInternal()->m_handle);
// don't call perform, because events must be async
// timeout will occur and do curl_multi_perform
if (ret && ret != CURLM_CALL_MULTI_PERFORM) {
#ifndef NDEBUG
printf("Error %d starting job %s\n", ret, encodeWithURLEscapeSequences(job->request().url().string()).latin1().data());
#endif
job->cancel();
return;
}
}
void ResourceHandleManager::dispatchSynchronousJob(ResourceHandle* job)
{
KURL kurl = job->request().url();
if (kurl.protocolIs("data")) {
parseDataUrl(job);
return;
}
initializeHandle(job);
ResourceHandleInternal* handle = job->getInternal();
// curl_easy_perform blocks until the transfert is finished.
CURLcode ret = curl_easy_perform(handle->m_handle);
if (ret != 0) {
ResourceError error(String(handle->m_url), ret, String(handle->m_url), String(curl_easy_strerror(ret)));
handle->client()->didFail(job, error);
}
curl_easy_cleanup(handle->m_handle);
}
TEST_F(AggregationHandleAvgDeathTest, VarTypeTest) {
const Type &type = VarCharType::Instance(true, 10);
EXPECT_DEATH(initializeHandle(type), "");
}
