SemanticResults::Names SemanticResults::semanticResults(const SPPHRASEPROPERTY * pProperty) {
Names names;
if (pProperty) {
names.insert({ RuleName::withoutChoiceIndex(pProperty->pszName) , pProperty->pszName });
if (pProperty->pFirstChild) {
Names children = semanticResults(pProperty->pFirstChild);
names.insert(children.begin(), children.end());
}
if (pProperty->pNextSibling) {
Names children = semanticResults(pProperty->pNextSibling);
names.insert(children.begin(), children.end());
}
}
return names;
}
DBusBrowser::DBusBrowser(::DBus::Connection &conn)
: ::DBus::ObjectProxy(conn, DBUS_SERVER_PATH, DBUS_SERVER_NAME)
{
set_title("D-Bus Browser");
set_border_width(5);
set_default_size(400, 500);
typedef std::vector< std::string > Names;
Names names = ListNames();
for (Names::iterator it = names.begin(); it != names.end(); ++it)
{
_cb_busnames.append_text(*it);
}
_cb_busnames.signal_changed().connect(sigc::mem_fun(*this, &DBusBrowser::on_select_busname));
_tm_inspect = Gtk::TreeStore::create(_records);
_tv_inspect.set_model(_tm_inspect);
_tv_inspect.append_column("Node", _records.name);
_sc_tree.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
_sc_tree.add(_tv_inspect);
_vbox.pack_start(_cb_busnames, Gtk::PACK_SHRINK);
_vbox.pack_start(_sc_tree);
add(_vbox);
show_all_children();
}
void Path::set( size_t begin, size_t end, const Names &names )
{
if( begin > m_names.size() )
{
throw IECore::Exception( "Index out of range" );
}
if( end > m_names.size() )
{
throw IECore::Exception( "Index out of range" );
}
Names::difference_type sizeDifference = names.size() - (end - begin);
if( sizeDifference == 0 )
{
if( equal( m_names.begin() + begin, m_names.begin() + end, names.begin() ) )
{
return;
}
}
else if( sizeDifference > 0 )
{
m_names.resize( m_names.size() + sizeDifference );
std::copy_backward( m_names.begin() + end, m_names.begin() + end + sizeDifference, m_names.end() );
}
else
{
std::copy( m_names.begin() + end, m_names.end(), m_names.begin() + end + sizeDifference );
m_names.resize( m_names.size() + sizeDifference );
}
std::copy( names.begin(), names.end(), m_names.begin() + begin );
emitPathChanged();
}
BlockInputStreams StorageSystemTables::read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum /*processed_stage*/,
const size_t max_block_size,
const unsigned /*num_streams*/)
{
check(column_names);
/// Create a mask of what columns are needed in the result.
NameSet names_set(column_names.begin(), column_names.end());
Block sample_block = getSampleBlock();
Block res_block;
std::vector<UInt8> columns_mask(sample_block.columns());
for (size_t i = 0, size = columns_mask.size(); i < size; ++i)
{
if (names_set.count(sample_block.getByPosition(i).name))
{
columns_mask[i] = 1;
res_block.insert(sample_block.getByPosition(i));
}
}
ColumnPtr filtered_databases_column = getFilteredDatabases(query_info.query, context);
return {std::make_shared<TablesBlockInputStream>(
std::move(columns_mask), std::move(res_block), max_block_size, std::move(filtered_databases_column), context)};
}
string name(const char* baseName)
{
Names::iterator p = names_number_.find(string(baseName));
int id = (p == names_number_.end()) ? 0 : names_number_[baseName] + 1;
names_number_[baseName] = id;
enum { BufferSize = 14 };
char buffer[BufferSize];
snprintf(buffer, BufferSize, "_%d", id);
return (string(baseName) + buffer + ".log").c_str();
}
/**
* @brief Reloads the ui scripts and reinitializes the ui
*/
static void UI_Restart_f (void)
{
typedef std::vector<std::string> Names;
Names names;
for (int i = 0; i < ui_global.windowStackPos; i++) {
names.push_back(std::string(ui_global.windowStack[i]->name));
}
UI_Shutdown();
CLMN_Shutdown();
R_FontShutdown();
UI_Init();
R_FontInit();
Com_Printf("%i ui script files\n", FS_BuildFileList("ufos/ui/*.ufo"));
FS_NextScriptHeader(nullptr, nullptr, nullptr);
const char* type, *name, *text;
text = nullptr;
while ((type = FS_NextScriptHeader("ufos/*.ufo", &name, &text)) != nullptr) {
if (Q_streq(type, "font"))
UI_ParseFont(name, &text);
else if (Q_streq(type, "menu_model"))
UI_ParseUIModel(name, &text);
else if (Q_streq(type, "sprite"))
UI_ParseSprite(name, &text);
}
UI_Reinit();
FS_NextScriptHeader(nullptr, nullptr, nullptr);
text = nullptr;
while ((type = FS_NextScriptHeader("ufos/ui/*.ufo", &name, &text)) != nullptr) {
if (Q_streq(type, "window"))
UI_ParseWindow(type, name, &text);
else if (Q_streq(type, "component"))
UI_ParseComponent(type, name, &text);
else if (Q_streq(type, "menu_model"))
UI_ParseUIModel(name, &text);
else if (Q_streq(type, "sprite"))
UI_ParseSprite(name, &text);
else if (Q_streq(type, "lua"))
UI_ParseAndLoadLuaScript(name, &text);
}
CLMN_Init();
for (Names::iterator i = names.begin(); i != names.end(); ++i) {
UI_PushWindow(i->c_str());
}
}
BlockInputStreams StorageStripeLog::read(
const Names & column_names,
const SelectQueryInfo & /*query_info*/,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
const size_t /*max_block_size*/,
unsigned num_streams)
{
std::shared_lock<std::shared_mutex> lock(rwlock);
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
NameSet column_names_set(column_names.begin(), column_names.end());
if (!Poco::File(full_path() + "index.mrk").exists())
return { std::make_shared<NullBlockInputStream>() };
CompressedReadBufferFromFile index_in(full_path() + "index.mrk", 0, 0, INDEX_BUFFER_SIZE);
std::shared_ptr<const IndexForNativeFormat> index{std::make_shared<IndexForNativeFormat>(index_in, column_names_set)};
BlockInputStreams res;
size_t size = index->blocks.size();
if (num_streams > size)
num_streams = size;
for (size_t stream = 0; stream < num_streams; ++stream)
{
IndexForNativeFormat::Blocks::const_iterator begin = index->blocks.begin();
IndexForNativeFormat::Blocks::const_iterator end = index->blocks.begin();
std::advance(begin, stream * size / num_streams);
std::advance(end, (stream + 1) * size / num_streams);
res.emplace_back(std::make_shared<StripeLogBlockInputStream>(
*this, context.getSettingsRef().max_read_buffer_size, index, begin, end));
}
/// We do not keep read lock directly at the time of reading, because we read ranges of data that do not change.
return res;
}
void C2Sema::analyseStructNames(const StructTypeDecl* S, Names& names) {
typedef Names::iterator NamesIter;
for (unsigned i=0; i<S->numMembers(); i++) {
const Decl* member = S->getMember(i);
const std::string& name = member->getName();
if (name == "") {
assert(isa<StructTypeDecl>(member));
analyseStructNames(cast<StructTypeDecl>(member), names);
} else {
NamesIter iter = names.find(name);
if (iter != names.end()) {
const Decl* existing = iter->second;
Diag(member->getLocation(), diag::err_duplicate_member) << name;
Diag(existing->getLocation(), diag::note_previous_declaration);
} else {
names[name] = member;
}
}
}
}
NamesAndTypesList NamesAndTypesList::filter(const Names & names) const
{
return filter(NameSet(names.begin(), names.end()));
}
void Join::joinBlockImpl(
Block & block,
const Names & key_names_left,
const NameSet & needed_key_names_right,
const Block & block_with_columns_to_add,
const Maps & maps_) const
{
size_t keys_size = key_names_left.size();
ColumnRawPtrs key_columns(keys_size);
/// Rare case, when keys are constant. To avoid code bloat, simply materialize them.
Columns materialized_columns;
materialized_columns.reserve(keys_size);
/// Memoize key columns to work with.
for (size_t i = 0; i < keys_size; ++i)
{
materialized_columns.emplace_back(recursiveRemoveLowCardinality(block.getByName(key_names_left[i]).column->convertToFullColumnIfConst()));
key_columns[i] = materialized_columns.back().get();
}
/// Keys with NULL value in any column won't join to anything.
ColumnPtr null_map_holder;
ConstNullMapPtr null_map{};
extractNestedColumnsAndNullMap(key_columns, null_map_holder, null_map);
size_t existing_columns = block.columns();
/** If you use FULL or RIGHT JOIN, then the columns from the "left" table must be materialized.
* Because if they are constants, then in the "not joined" rows, they may have different values
* - default values, which can differ from the values of these constants.
*/
if (getFullness(kind))
{
for (size_t i = 0; i < existing_columns; ++i)
{
block.getByPosition(i).column = block.getByPosition(i).column->convertToFullColumnIfConst();
/// If use_nulls, convert left columns (except keys) to Nullable.
if (use_nulls)
{
if (std::end(key_names_left) == std::find(key_names_left.begin(), key_names_left.end(), block.getByPosition(i).name))
convertColumnToNullable(block.getByPosition(i));
}
}
}
/** For LEFT/INNER JOIN, the saved blocks do not contain keys.
* For FULL/RIGHT JOIN, the saved blocks contain keys;
* but they will not be used at this stage of joining (and will be in `AdderNonJoined`), and they need to be skipped.
*/
size_t num_columns_to_skip = 0;
if (getFullness(kind))
num_columns_to_skip = keys_size;
/// Add new columns to the block.
size_t num_columns_to_add = sample_block_with_columns_to_add.columns();
MutableColumns added_columns;
added_columns.reserve(num_columns_to_add);
std::vector<std::pair<decltype(ColumnWithTypeAndName::type), decltype(ColumnWithTypeAndName::name)>> added_type_name;
added_type_name.reserve(num_columns_to_add);
std::vector<size_t> right_indexes;
right_indexes.reserve(num_columns_to_add);
for (size_t i = 0; i < num_columns_to_add; ++i)
{
const ColumnWithTypeAndName & src_column = sample_block_with_columns_to_add.safeGetByPosition(i);
/// Don't insert column if it's in left block or not explicitly required.
if (!block.has(src_column.name) && block_with_columns_to_add.has(src_column.name))
{
added_columns.push_back(src_column.column->cloneEmpty());
added_columns.back()->reserve(src_column.column->size());
added_type_name.emplace_back(src_column.type, src_column.name);
right_indexes.push_back(num_columns_to_skip + i);
}
}
size_t rows = block.rows();
std::unique_ptr<IColumn::Filter> filter;
bool filter_left_keys = (kind == ASTTableJoin::Kind::Inner || kind == ASTTableJoin::Kind::Right) && strictness == ASTTableJoin::Strictness::Any;
filter = std::make_unique<IColumn::Filter>(rows);
/// Used with ALL ... JOIN
IColumn::Offset current_offset = 0;
std::unique_ptr<IColumn::Offsets> offsets_to_replicate;
if (strictness == ASTTableJoin::Strictness::All)
offsets_to_replicate = std::make_unique<IColumn::Offsets>(rows);
switch (type)
{
#define M(TYPE) \
case Join::Type::TYPE: \
joinBlockImplType<KIND, STRICTNESS, typename KeyGetterForType<Join::Type::TYPE>::Type>(\
*maps_.TYPE, rows, key_columns, key_sizes, added_columns, null_map, \
filter, current_offset, offsets_to_replicate, right_indexes); \
break;
APPLY_FOR_JOIN_VARIANTS(M)
#undef M
default:
throw Exception("Unknown JOIN keys variant.", ErrorCodes::UNKNOWN_SET_DATA_VARIANT);
}
const auto added_columns_size = added_columns.size();
for (size_t i = 0; i < added_columns_size; ++i)
block.insert(ColumnWithTypeAndName(std::move(added_columns[i]), added_type_name[i].first, added_type_name[i].second));
/// If ANY INNER | RIGHT JOIN - filter all the columns except the new ones.
if (filter_left_keys)
for (size_t i = 0; i < existing_columns; ++i)
block.safeGetByPosition(i).column = block.safeGetByPosition(i).column->filter(*filter, -1);
ColumnUInt64::Ptr mapping;
/// Add join key columns from right block if they has different name.
for (size_t i = 0; i < key_names_right.size(); ++i)
{
auto & right_name = key_names_right[i];
auto & left_name = key_names_left[i];
if (needed_key_names_right.count(right_name) && !block.has(right_name))
{
const auto & col = block.getByName(left_name);
auto column = col.column;
if (!filter_left_keys)
{
if (!mapping)
{
auto mut_mapping = ColumnUInt64::create(column->size());
auto & data = mut_mapping->getData();
size_t size = column->size();
for (size_t j = 0; j < size; ++j)
data[j] = (*filter)[j] ? j : size;
mapping = std::move(mut_mapping);
}
auto mut_column = (*std::move(column)).mutate();
mut_column->insertDefault();
column = mut_column->index(*mapping, 0);
}
block.insert({column, col.type, right_name});
}
}
/// If ALL ... JOIN - we replicate all the columns except the new ones.
if (offsets_to_replicate)
{
for (size_t i = 0; i < existing_columns; ++i)
block.safeGetByPosition(i).column = block.safeGetByPosition(i).column->replicate(*offsets_to_replicate);
}
}