ArrayDesc inferSchema(std::vector<ArrayDesc> schemas, boost::shared_ptr<Query> query) { assert(schemas.size() == 1); ArrayDesc const& desc = schemas[0]; size_t nDims = desc.getDimensions().size(); vector<WindowBoundaries> window(nDims); size_t windowSize = 1; for (size_t i = 0, size = nDims * 2, boundaryNo = 0; i < size; i+=2, ++boundaryNo) { window[boundaryNo] = WindowBoundaries( evaluate(((boost::shared_ptr<OperatorParamLogicalExpression>&)_parameters[i]) ->getExpression(), query, TID_INT64).getInt64(), evaluate(((boost::shared_ptr<OperatorParamLogicalExpression>&)_parameters[i+1]) ->getExpression(), query, TID_INT64).getInt64() ); windowSize *= window[boundaryNo]._boundaries.second + window[boundaryNo]._boundaries.first + 1; if (window[boundaryNo]._boundaries.first < 0) throw USER_QUERY_EXCEPTION(SCIDB_SE_INFER_SCHEMA, SCIDB_LE_OP_WINDOW_ERROR3, _parameters[i]->getParsingContext()); if (window[boundaryNo]._boundaries.second < 0) throw USER_QUERY_EXCEPTION(SCIDB_SE_INFER_SCHEMA, SCIDB_LE_OP_WINDOW_ERROR3, _parameters[i + 1]->getParsingContext()); } if (windowSize <= 1) throw USER_QUERY_EXCEPTION(SCIDB_SE_INFER_SCHEMA, SCIDB_LE_OP_WINDOW_ERROR4, _parameters[0]->getParsingContext()); return createWindowDesc(desc); }
ArrayDesc inferSchema(std::vector<ArrayDesc> schemas, boost::shared_ptr<Query> query) { assert(schemas.size() == 1); ArrayDesc const& schema = schemas[0]; Dimensions const& dims = schema.getDimensions(); size_t nDims = dims.size(); size_t nParams = _parameters.size(); assert((nParams & 1) == 0 || nParams >= nDims*2); Dimensions newDims(nDims - nParams/2); if (newDims.size() <= 0) throw USER_EXCEPTION(SCIDB_SE_INFER_SCHEMA, SCIDB_LE_OP_SLICE_ERROR1); std::vector<std::string> sliceDimName(nParams/2); for (size_t i = 0; i < nParams; i+=2) { sliceDimName[i >> 1] = ((boost::shared_ptr<OperatorParamReference>&)_parameters[i])->getObjectName(); } size_t j = 0; for (size_t i = 0; i < nDims; i++) { const std::string dimName = dims[i].getBaseName(); int k = sliceDimName.size(); while (--k >= 0 && sliceDimName[k] != dimName && !(sliceDimName[k][0] == '_' && (size_t)atoi(sliceDimName[k].c_str()+1) == i+1)); if (k < 0) { if (j >= newDims.size()) throw USER_QUERY_EXCEPTION(SCIDB_SE_INFER_SCHEMA, SCIDB_LE_DUPLICATE_DIMENSION_NAME, _parameters[i]->getParsingContext()) << dimName; newDims[j++] = dims[i]; } } return ArrayDesc(schema.getName(), schema.getAttributes(), newDims); }
ArrayDesc inferSchema(std::vector<ArrayDesc> schemas, std::shared_ptr<Query> query) { assert(schemas.size() == 0); assert(_parameters.size() == 2); assert(((std::shared_ptr<OperatorParam>&)_parameters[0])->getParamType() == PARAM_ARRAY_REF); assert(((std::shared_ptr<OperatorParam>&)_parameters[1])->getParamType() == PARAM_ARRAY_REF); std::string oldArrayName; std::string oldNamespaceName; std::string newArrayName; std::string newNamespaceName; const string &oldArrayNameOrg = ((std::shared_ptr<OperatorParamReference>&)_parameters[0])->getObjectName(); query->getNamespaceArrayNames(oldArrayNameOrg, oldNamespaceName, oldArrayName); const string &newArrayNameOrg = ((std::shared_ptr<OperatorParamReference>&)_parameters[1])->getObjectName(); query->getNamespaceArrayNames(newArrayNameOrg, newNamespaceName, newArrayName); if(newNamespaceName != oldNamespaceName) { throw USER_QUERY_EXCEPTION( SCIDB_SE_INFER_SCHEMA, SCIDB_LE_CANNOT_RENAME_ACROSS_NAMESPACES, _parameters[1]->getParsingContext()) << ArrayDesc::makeQualifiedArrayName(oldNamespaceName, oldArrayName) << ArrayDesc::makeQualifiedArrayName(newNamespaceName, newArrayName); } if (scidb::namespaces::Communicator::containsArray(newNamespaceName, newArrayName)) { throw USER_QUERY_EXCEPTION(SCIDB_SE_INFER_SCHEMA, SCIDB_LE_ARRAY_ALREADY_EXIST, _parameters[1]->getParsingContext()) << newArrayName; } ArrayDesc arrDesc; arrDesc.setDistribution(defaultPartitioning()); arrDesc.setResidency(query->getDefaultArrayResidency()); return arrDesc; }
ArrayDesc inferSchema(std::vector<ArrayDesc> schemas, boost::shared_ptr<Query> query) { assert(schemas.size() == 0); assert(_parameters.size() == 2); assert(((boost::shared_ptr<OperatorParam>&)_parameters[1])->getParamType() == PARAM_ARRAY_REF); const string &newArrayName = ((boost::shared_ptr<OperatorParamReference>&)_parameters[1])->getObjectName(); if (SystemCatalog::getInstance()->containsArray(newArrayName)) { throw USER_QUERY_EXCEPTION(SCIDB_SE_INFER_SCHEMA, SCIDB_LE_ARRAY_ALREADY_EXIST, _parameters[1]->getParsingContext()) << newArrayName; } return ArrayDesc(); }
ArrayDesc inferSchema(std::vector<ArrayDesc> schemas, boost::shared_ptr<Query> query) { assert(schemas.size() == 1); ArrayDesc const& desc = schemas[0]; size_t nDims = desc.getDimensions().size(); vector<size_t> window(nDims); for (size_t i = 0; i < nDims; i++) { window[i] = evaluate(((boost::shared_ptr<OperatorParamLogicalExpression>&)_parameters[i])->getExpression(), query, TID_INT64).getInt64(); if ((ssize_t)window[i] <= 0) throw USER_QUERY_EXCEPTION(SCIDB_SE_INFER_SCHEMA, SCIDB_LE_OP_WINDOW_ERROR1, _parameters[i]->getParsingContext()); } return createWindowDesc(desc, window); }
ArrayDesc inferSchema(std::vector<ArrayDesc> schemas, std::shared_ptr<Query> query) { assert(schemas.size() == 1); ArrayDesc const& inputDesc = schemas[0]; size_t nDims = inputDesc.getDimensions().size(); Dimensions outDims(nDims); // How many parameters are of each type. size_t numAggregateCalls = 0; size_t numChunkSizes = 0; for (size_t i = nDims, n = _parameters.size(); i < n; ++i) { if (_parameters[i]->getParamType() == PARAM_AGGREGATE_CALL) { ++numAggregateCalls; } else // chunk size { ++numChunkSizes; } } if (numChunkSizes && numChunkSizes != nDims) { throw USER_EXCEPTION(SCIDB_SE_INFER_SCHEMA, SCIDB_LE_NUM_CHUNKSIZES_NOT_MATCH_NUM_DIMS) << "regrid()"; } // Generate the output dims. for (size_t i = 0; i < nDims; i++) { int64_t blockSize = evaluate(((std::shared_ptr<OperatorParamLogicalExpression>&)_parameters[i])->getExpression(), query, TID_INT64).getInt64(); if (blockSize <= 0) { throw USER_QUERY_EXCEPTION(SCIDB_SE_INFER_SCHEMA, SCIDB_LE_OP_REGRID_ERROR1, _parameters[i]->getParsingContext()); } DimensionDesc const& srcDim = inputDesc.getDimensions()[i]; int64_t chunkSize = srcDim.getRawChunkInterval(); if (numChunkSizes) { size_t index = i + nDims + numAggregateCalls; chunkSize = evaluate(((std::shared_ptr<OperatorParamLogicalExpression>&)_parameters[index])->getExpression(), query, TID_INT64).getInt64(); if (chunkSize<=0) { throw USER_EXCEPTION(SCIDB_SE_INFER_SCHEMA, SCIDB_LE_CHUNK_SIZE_MUST_BE_POSITIVE); } } outDims[i] = DimensionDesc( srcDim.getBaseName(), srcDim.getNamesAndAliases(), srcDim.getStartMin(), srcDim.getStartMin(), srcDim.getEndMax() == CoordinateBounds::getMax() ? CoordinateBounds::getMax() : srcDim.getStartMin() + (srcDim.getLength() + blockSize - 1)/blockSize - 1, srcDim.getEndMax() == CoordinateBounds::getMax() ? CoordinateBounds::getMax() : srcDim.getStartMin() + (srcDim.getLength() + blockSize - 1)/blockSize - 1, chunkSize, 0 ); } // Input and output dimensions are 1-to-1, so... _fixer.takeAllDimensions(inputDesc.getDimensions()); ArrayDesc outSchema(inputDesc.getName(), Attributes(), outDims, defaultPartitioning(), query->getDefaultArrayResidency() ); for (size_t i = nDims, j=nDims+numAggregateCalls; i<j; i++) { bool isInOrderAggregation = false; addAggregatedAttribute( (std::shared_ptr <OperatorParamAggregateCall> &) _parameters[i], inputDesc, outSchema, isInOrderAggregation); } AttributeDesc et ((AttributeID) outSchema.getAttributes().size(), DEFAULT_EMPTY_TAG_ATTRIBUTE_NAME, TID_INDICATOR, AttributeDesc::IS_EMPTY_INDICATOR, 0); outSchema.addAttribute(et); return outSchema; }