TupleSchema* TupleSchema::createTupleSchema(const std::vector<ValueType>& columnTypes,
const std::vector<int32_t>& columnSizes,
const std::vector<bool>& allowNull,
const std::vector<bool>& columnInBytes,
const std::vector<ValueType>& hiddenColumnTypes,
const std::vector<int32_t>& hiddenColumnSizes,
const std::vector<bool>& hiddenAllowNull,
const std::vector<bool>& hiddenColumnInBytes)
{
const uint16_t uninlineableObjectColumnCount =
TupleSchema::countUninlineableObjectColumns(columnTypes, columnSizes, columnInBytes);
const uint16_t columnCount = static_cast<uint16_t>(columnTypes.size());
const uint16_t hiddenColumnCount = static_cast<uint16_t>(hiddenColumnTypes.size());
int memSize = memSizeForTupleSchema(columnCount,
uninlineableObjectColumnCount,
hiddenColumnCount);
// allocate the set amount of memory and cast it to a tuple pointer
TupleSchema *retval = reinterpret_cast<TupleSchema*>(new char[memSize]);
// clear all the offset values
memset(retval, 0, memSize);
retval->m_columnCount = columnCount;
retval->m_uninlinedObjectColumnCount = uninlineableObjectColumnCount;
retval->m_hiddenColumnCount = hiddenColumnCount;
retval->m_isHeaderless = false;
uint16_t uninlinedObjectColumnIndex = 0;
for (uint16_t ii = 0; ii < columnCount; ii++) {
const ValueType type = columnTypes[ii];
const uint32_t length = columnSizes[ii];
const bool columnAllowNull = allowNull[ii];
const bool inBytes = columnInBytes[ii];
retval->setColumnMetaData(ii, type, length, columnAllowNull, uninlinedObjectColumnIndex, inBytes);
}
for (uint16_t ii = 0; ii < hiddenColumnCount; ++ii) {
const ValueType type = hiddenColumnTypes[ii];
const uint32_t length = hiddenColumnSizes[ii];
const bool columnAllowNull = hiddenAllowNull[ii];
const bool inBytes = hiddenColumnInBytes[ii];
// We can't allow uninlineable data in hidden columns yet
if (! isInlineable(type, length, inBytes)) {
throwFatalLogicErrorStreamed("Attempt to create uninlineable hidden column");
}
retval->setColumnMetaData(static_cast<uint16_t>(columnCount + ii),
type,
length,
columnAllowNull,
uninlinedObjectColumnIndex,
inBytes);
}
return retval;
}
void TupleSchema::setColumnMetaData(uint16_t index, ValueType type, const int32_t length, bool allowNull,
uint16_t &uninlinedObjectColumnIndex, bool inBytes)
{
assert(length <= COLUMN_MAX_VALUE_LENGTH);
uint32_t offset = 0;
// set the type
ColumnInfo *columnInfo = getColumnInfoPrivate(index);
columnInfo->type = static_cast<char>(type);
columnInfo->allowNull = (char)(allowNull ? 1 : 0);
columnInfo->length = length;
columnInfo->inBytes = inBytes;
if (type == VALUE_TYPE_VARCHAR || type == VALUE_TYPE_VARBINARY) {
if (length == 0) {
throwFatalLogicErrorStreamed("Zero length for object type " << valueToString((ValueType)type));
}
if (isInlineable(type, length, inBytes)) {
columnInfo->inlined = true;
// If the length was specified in characters, convert to bytes.
int32_t factor = (type == VALUE_TYPE_VARCHAR && !inBytes) ? MAX_BYTES_PER_UTF8_CHARACTER : 1;
// inlined variable length columns have a size prefix (1 byte)
offset = static_cast<uint32_t>(SHORT_OBJECT_LENGTHLENGTH + (length * factor));
} else {
columnInfo->inlined = false;
// Set the length to the size of a String pointer since it won't be inlined.
offset = static_cast<uint32_t>(NValue::getTupleStorageSize(type));
setUninlinedObjectColumnInfoIndex(uninlinedObjectColumnIndex++, index);
}
} else {
// All values are inlined if they aren't strings.
columnInfo->inlined = true;
// don't trust the planner since it can be avoided
offset = static_cast<uint32_t>(NValue::getTupleStorageSize(type));
}
// make the column offsets right for all columns past this one
int oldsize = columnLengthPrivate(index);
ColumnInfo *nextColumnInfo = NULL;
for (int i = index + 1; i <= totalColumnCount(); i++) {
nextColumnInfo = getColumnInfoPrivate(i);
nextColumnInfo->offset = static_cast<uint32_t>(nextColumnInfo->offset + offset - oldsize);
}
assert(index == 0 ? columnInfo->offset == 0 : true);
}
/*
* Returns the number of variable-length columns that can't be inlined.
*/
uint16_t TupleSchema::countUninlineableObjectColumns(
const std::vector<ValueType> columnTypes,
const std::vector<int32_t> columnSizes,
const std::vector<bool> columnInBytes)
{
const uint16_t numColumns = static_cast<uint16_t>(columnTypes.size());
uint16_t numUninlineableObjects = 0;
for (int ii = 0; ii < numColumns; ii++) {
ValueType vt = columnTypes[ii];
if (! isInlineable(vt, columnSizes[ii], columnInBytes[ii])) {
numUninlineableObjects++;
}
}
return numUninlineableObjects;
}
int32_t OMR::RecognizedCallTransformer::perform()
{
TR::NodeChecklist visited(comp());
for (auto treetop = comp()->getMethodSymbol()->getFirstTreeTop(); treetop != NULL; treetop = treetop->getNextTreeTop())
{
if (treetop->getNode()->getNumChildren() > 0)
{
auto node = treetop->getNode()->getFirstChild();
if (node && node->getOpCode().isCall() && !visited.contains(node))
{
if (isInlineable(treetop) &&
performTransformation(comp(), "%s Transforming recognized call node [" POINTER_PRINTF_FORMAT "]\n", optDetailString(), node))
{
visited.add(node);
transform(treetop);
}
}
}
}
return 0;
}
