Beispiel #1
0
            void session::query_schema(const string &dbName, const string &tableName, std::vector<column_definition> &columns)
            {
                if (!is_open()) return;

                // TODO: use binding for table parameter
                string pk_sql =
                    string("SELECT tc.table_schema, tc.table_name, kc.column_name FROM information_schema.table_constraints tc ") +
                    "JOIN information_schema.key_column_usage kc ON kc.table_name = tc.table_name AND kc.table_schema = tc.table_schema  " +
                    "WHERE tc.constraint_type = 'PRIMARY KEY' AND tc.table_name = '" + tableName + "' AND tc.table_schema = '" + dbName +
                    "' ORDER BY tc.table_schema, tc.table_name, "
                    "kc.position_in_unique_constraint;";

                string col_sql = "SELECT column_name, data_type, extra, column_default FROM information_schema.columns WHERE table_name = '" +
                                 tableName + "' AND table_schema = '" + dbName + "';";

                auto rs = query(col_sql);

                auto primary_keys = query(pk_sql);

                while (rs->next()) {
                    auto row = rs->current_row();
                    column_definition def;

                    // column name
                    def.name = row["column_name"].to_value().to_string();

                    if (def.name.empty()) {
                        continue;
                    }

                    def.pk = false;
                    def.autoincrement = false;

                    primary_keys->reset();

                    while (primary_keys->next()) {
                        auto pk = primary_keys->current_row();
                        if (pk["column_name"].to_value() == def.name) {
                            def.pk = true;
                            def.autoincrement = row["extra"].to_value() == "auto_increment";
                        }
                    }

                    // find type
                    def.type = row["data_type"].to_value().to_string();

                    def.default_value = row["column_default"].to_value().to_string();

                    columns.push_back(def);
                }
            }
Beispiel #2
0
            void session::query_schema(const string &dbName, const string &tableName, std::vector<column_definition> &columns)
            {
                if (tableName.empty()) {
                    throw database_exception("no table name to query schema");
                }

                auto rs = query("pragma table_info(" + tableName + ")");

                while (rs->next()) {
                    auto row = rs->current_row();
                    column_definition def;

                    // column name
                    def.name = row["name"].to_value().to_string();

                    // primary key check
                    def.pk = row["pk"].to_value().to_bool();

                    // find type
                    def.type = row["type"].to_value().to_string();

                    def.autoincrement = def.pk;

                    def.default_value = row["dflt_value"].to_value().to_string();

                    columns.push_back(def);
                }
            }
Beispiel #3
0
/* printf-style print function which calls printw, but only if the cursor is
 * not on the last line. */
static void print(const char *fmt, ...)
{
	va_list args;

	if(current_row() < lines()-1) {
		va_start(args, fmt);
		vw_printw(stdscr, fmt, args);
		va_end(args);
	}
}
Beispiel #4
0
static void top(void)
{
	xenstat_domain **domains;
	unsigned int i, num_domains = 0;

	/* Now get the node information */
	if (prev_node != NULL)
		xenstat_free_node(prev_node);
	prev_node = cur_node;
	cur_node = xenstat_get_node(xhandle, XENSTAT_ALL);
	if (cur_node == NULL)
		fail("Failed to retrieve statistics from libxenstat\n");

	/* dump summary top information */
	if (!batch)
		do_summary();

	/* Count the number of domains for which to report data */
	num_domains = xenstat_node_num_domains(cur_node);

	domains = calloc(num_domains, sizeof(xenstat_domain *));
	if(domains == NULL)
		fail("Failed to allocate memory\n");

	for (i=0; i < num_domains; i++)
		domains[i] = xenstat_node_domain_by_index(cur_node, i);

	/* Sort */
	qsort(domains, num_domains, sizeof(xenstat_domain *),
	      (int(*)(const void *, const void *))compare_domains);

	if(first_domain_index >= num_domains)
		first_domain_index = num_domains-1;

	for (i = first_domain_index; i < num_domains; i++) {
		if(!batch && current_row() == lines()-1)
			break;
		if (i == first_domain_index || repeat_header)
			do_header();
		do_domain(domains[i]);
		if (show_vcpus)
			do_vcpu(domains[i]);
		if (show_networks)
			do_network(domains[i]);
		if (show_vbds)
			do_vbd(domains[i]);
		if (show_tmem)
			do_tmem(domains[i]);
	}

	if (!batch)
		do_bottom_line();

	free(domains);
}
Beispiel #5
0
int SCP_instance::exclude_a_row(int row_id)
{
	row_covered[row_id] = true;
	row_excluded[row_id] = true;
	set<int> &current_row((*rows)[row_id]);
	for (set<int>::iterator iterator1 = current_row.begin(); iterator1 != current_row.end(); iterator1++)
	{
		((*columns)[*iterator1]).erase(row_id);
	}
	((*rows)[row_id]).clear();
	return 0;
};
Beispiel #6
0
/* printf-style print function which calls printw, but only if the cursor is
 * not on the last line. */
static void print(const char *fmt, ...)
{
	va_list args;

	if (!batch) {
		if((current_row() < lines()-1)) {
			va_start(args, fmt);
			vwprintw(stdscr, (curses_str_t)fmt, args);
			va_end(args);
		}
	} else {
		va_start(args, fmt);
		vprintf(fmt, args);
		va_end(args);
	}
}
Beispiel #7
0
int SCP_instance::include_a_column(int column_id)
{
	column_chosen[column_id] = true;

	/*Make a copy of the column*/
	set<int> copy_of_the_column = (*columns)[column_id];
	
	/* (*iterator1) is the row_id */
	for (set<int>::iterator iterator1 = copy_of_the_column.begin(); iterator1 != copy_of_the_column.end(); iterator1++)
	{
		set<int> &current_row((*rows)[*iterator1]);
		/* (*iterator2) is the column id */
		for (set<int>::iterator iterator2 = current_row.begin(); iterator2 != current_row.end(); iterator2++)
		{
			((*columns)[*iterator2]).erase(*iterator1);
		}
		((*rows)[*iterator1]).clear();
		row_covered[*iterator1] = true;
	};
	((*columns)[column_id]).clear();
	return 0;
};
Beispiel #8
0
void SCP_instance::consistency_checking()
{
	/*check that the numbers within the rows and the columns are all legitimate*/
	for (int ii = 0; ii < number_of_rows; ii++)
	{
		set<int> &current_row((*rows)[ii]);
		for (set<int>::iterator iterator1= current_row.begin(); iterator1 != current_row.end(); iterator1 ++)
		{
			if (((*iterator1) >= number_of_columns) or ((*iterator1) < 0))
			{
				cout << "EXCEPTION: within SCP_instance::consistency_checking the number is invalid" << endl;
			}
		}
	}
	
	for (int ii = 0; ii < number_of_columns; ii++)
	{
		set<int> &current_column((*columns)[ii]);
		for (set<int>::iterator iterator1= current_column.begin(); iterator1 != current_column.end(); iterator1 ++)
		{
			if (((*iterator1) >= number_of_rows) or ((*iterator1) < 0))
			{
				cout << "EXCEPTION: within SCP_instance::consistency_checking the number is invalid" << endl;
			}
		}
	}
	
	/*check that none of the rows or columns are empty*/
	for (int ii = 0 ; ii < number_of_rows; ii++)
	{
		if (((*rows)[ii]).size() == 0)
		{
			cout << "EXCEPTION within SCP_instance::consistency_checking, an empty row" << endl;
		}
	}
	
	for (int ii = 0 ; ii < number_of_columns; ii++)
	{
		if (((*columns)[ii]).size() == 0 )
		{
			cout << "EXCEPTION within SCP_instance::consistency_checking, an empty column" << endl;
		}		
	}
									
	/*check that the rows and the columns are consistent with one another, and none of them are empty*/
	for (int ii = 0 ; ii < number_of_rows; ii ++)
	{
		set<int> & current_row((*rows)[ii]);
		for (set<int>::iterator iterator1 = current_row.begin(); iterator1 != current_row.end(); iterator1++)
		{
			if (((*columns)[*iterator1]).find(ii) == ((*columns)[*iterator1]).end())
			{
				cout << "ERROR, rows is not consistent with columns" << endl;
			}
		}
	}
	
	for (int ii = 0 ; ii < number_of_columns; ii ++)
	{
		set<int> & current_column((*columns)[ii]);
		for (set<int>::iterator iterator1 = current_column.begin(); iterator1 != current_column.end(); iterator1++)
		{
			if (((*rows)[*iterator1]).find(ii) == ((*rows)[*iterator1]).end())
			{
				cout << "ERROR, rows is not consistent with columns" << endl;
			}
		}
	}
	
};