void project_factory::init_data_schema(model_sptr m)
{
auto data = m->create_schema("data");
auto flat = data->create_table<table>("flat_table");
auto flat_id = flat->create_column("id");
auto flat_pk = flat->create_primary_key_constraint("pk_flat");
flat_pk->append(flat_id);
auto hierarchical = data->create_table<table>("hierarchical_table");
auto hierarchical_id = hierarchical->create_column("id");
auto hierarchical_parent_id = hierarchical->create_column("parent_id");
auto hierarchical_pk = hierarchical->create_primary_key_constraint("pk_hierarchical");
hierarchical_pk->append(hierarchical_id);
}
TbBool columns_add_static_entries(void)
{
struct Column *colmn;
struct Column lcolmn;
short *wptr;
short c[3];
long ncol;
long i,k;
for (i=0; i < 3; i++)
c[i] = 0;
LbMemorySet(&lcolmn,0,sizeof(struct Column));
wptr = &game.field_14A818[0];
for (i=0; i < 3; i++)
{
LbMemorySet(&lcolmn, 0, sizeof(struct Column));
lcolmn.baseblock = c[i];
for (k=0; k < 6; k++)
{
lcolmn.cubes[0] = player_cubes[k];
make_solidmask(&lcolmn);
ncol = find_column(&lcolmn);
if (ncol == 0)
ncol = create_column(&lcolmn);
colmn = get_column(ncol);
colmn->bitfields |= 0x01;
*wptr = -(short)ncol;
wptr++;
}
}
return true;
}
void init_whole_blocks(void)
{
struct Column *colmn;
struct Column lcolmn;
long i;
game.field_149E6E = -1;
LbMemorySet(&lcolmn, 0, sizeof(struct Column));
// Prepare the local column
lcolmn.baseblock = 22;
lcolmn.cubes[0] = 10;
lcolmn.cubes[1] = 1;
lcolmn.cubes[2] = 1;
lcolmn.cubes[3] = 1;
lcolmn.cubes[4] = 141;
make_solidmask(&lcolmn);
// Find it or add to column list
i = find_column(&lcolmn);
if (i == 0)
i = create_column(&lcolmn);
colmn = get_column(i);
// Update its parameters
colmn->bitfields |= 0x01;
game.field_149E7C = 24;
game.unrevealed_column_idx = i;
}
void test_set_and_get() {
constexpr size_t NUM_ROWS = 1 << 16;
// Create a table and insert the first row.
auto db = grnxx::open_db("");
auto table = db->create_table("Table");
auto column = table->create_column("Column", T::type());
grnxx::Array<T> values;
values.resize(NUM_ROWS);
for (size_t i = 0; i < NUM_ROWS; ++i) {
generate_random_value(&values[i]);
grnxx::Int row_id = table->insert_row();
column->set(row_id, values[i]);
grnxx::Datum datum;
column->get(row_id, &datum);
T stored_value;
datum.force(&stored_value);
assert(stored_value.match(values[i]));
}
// Test all the values again.
for (size_t i = 0; i < NUM_ROWS; ++i) {
grnxx::Int row_id = grnxx::Int(i);
grnxx::Datum datum;
column->get(row_id, &datum);
T stored_value;
datum.force(&stored_value);
assert(stored_value.match(values[i]));
}
}
void fx_search_initialize(FxSearch *search , GtkTreeModel *model
, const char *str , int x , int y)
{
GtkWidget *frame;
search->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_decorated(GTK_WINDOW(search->window) , FALSE);
gtk_window_set_type_hint(GTK_WINDOW(search->window), GDK_WINDOW_TYPE_HINT_DIALOG);
// gtk_widget_set_name(search->window , "mainwindow");
gtk_window_set_default_size(GTK_WINDOW(search->window) , 240 , 60);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW(search->window), TRUE);
gtk_window_move(GTK_WINDOW(search->window) , x , y);
g_signal_connect(search->window , "focus-out-event"
, GTK_SIGNAL_FUNC(window_focus_out) , search);
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame) , GTK_SHADOW_ETCHED_IN);
GtkTreeModel *nmodel = create_model(model , str);
search->view = gtk_tree_view_new_with_model(nmodel);
gtk_widget_set_usize(search->view , 320 , 0);
create_column(search->view , search->fxmain);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(search->view) , FALSE);
//gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (search->view), TRUE);
gtk_tree_view_set_hover_selection(GTK_TREE_VIEW(search->view) , TRUE);
gtk_container_add(GTK_CONTAINER(search->window) , frame);
gtk_container_add(GTK_CONTAINER(frame) , search->view);
g_signal_connect(search->view , "row-activated" , G_CALLBACK(row_activate_func) , search);
g_signal_connect(search->view , "button-press-event" , G_CALLBACK(button_press_func) , search);
g_signal_connect(search->view , "key-press-event" , G_CALLBACK(key_press_func) , search);
gtk_widget_show_all(search->window);
}
void test_basic_operations(const T &value) {
constexpr grnxx::DataType data_type = T::type();
// Create a table and insert the first row.
auto db = grnxx::open_db("");
auto table = db->create_table("Table");
grnxx::Int row_id = table->insert_row();
// Create a column named "Column".
auto column = table->create_column("Column", data_type);
assert(column->table() == table);
assert(column->name() == "Column");
assert(column->data_type() == data_type);
assert(!column->reference_table());
assert(!column->is_key());
assert(column->num_indexes() == 0);
// Check if N/A is stored or not.
grnxx::Datum datum;
T stored_value;
column->get(row_id, &datum);
assert(datum.type() == data_type);
datum.force(&stored_value);
assert(stored_value.is_na());
// Set a value and get it.
column->set(row_id, value);
column->get(row_id, &datum);
assert(datum.type() == data_type);
datum.force(&stored_value);
assert(stored_value.match(value));
}
static GtkWidget*
create_book_list_view(GtkListStore *store)
{
GtkWidget *list_view;
GtkTreeViewColumn *column;
list_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
column = create_column(TITLE_COLUMN, "Title", FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), column);
column = create_column(AUTHOR_COLUMN, "Author", FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), column);
column = create_column(CHECKED_COLUMN, "Checked", TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), column);
return list_view;
}
void test_text_key() {
// Create a table named "Table".
auto db = grnxx::open_db("");
auto table = db->create_table("Table");
// Create a column named "Column".
auto column = table->create_column("Column", GRNXX_TEXT);
// Append three rows.
grnxx::Int row_id = table->insert_row();
column->set(row_id, grnxx::Text("1"));
row_id = table->insert_row();
column->set(row_id, grnxx::Text("12"));
row_id = table->insert_row();
column->set(row_id, grnxx::Text("123"));
// Set key column.
table->set_key_column("Column");
assert(table->key_column() == column);
// Duplicate keys must be rejected.
bool inserted = true;
row_id = table->find_or_insert_row(grnxx::Text("1"), &inserted);
assert(row_id.raw() == 0);
assert(!inserted);
row_id = table->find_or_insert_row(grnxx::Text("12"), &inserted);
assert(row_id.raw() == 1);
assert(!inserted);
row_id = table->find_or_insert_row(grnxx::Text("123"), &inserted);
assert(row_id.raw() == 2);
assert(!inserted);
// Append new keys.
grnxx::Datum datum;
row_id = table->find_or_insert_row(grnxx::Text("A"), &inserted);
assert(row_id.raw() == 3);
assert(inserted);
row_id = table->find_or_insert_row(grnxx::Text("AB"), &inserted);
assert(row_id.raw() == 4);
assert(inserted);
row_id = table->find_or_insert_row(grnxx::Text("ABC"), &inserted);
assert(row_id.raw() == 5);
assert(inserted);
// Find rows by key.
assert(table->find_row(grnxx::Text("1")).raw() == 0);
assert(table->find_row(grnxx::Text("12")).raw() == 1);
assert(table->find_row(grnxx::Text("123")).raw() == 2);
assert(table->find_row(grnxx::Text("A")).raw() == 3);
assert(table->find_row(grnxx::Text("AB")).raw() == 4);
assert(table->find_row(grnxx::Text("ABC")).raw() == 5);
assert(table->find_row(grnxx::Text::na()).is_na());
// Unset key column.
table->unset_key_column();
assert(!table->key_column());
}
static GtkWidget *
create_tree_view(int n, n_list_store *list, int tree)
{
GType *tarray;
GtkTreeModel *lstore;
GtkWidget *tview;
GtkTreeViewColumn *col;
GtkTreeSelection *sel;
int i;
if (n < 1 || list == NULL)
return NULL;
tarray = g_malloc(sizeof(*tarray) * n);
if (tarray == NULL)
return NULL;
for (i = 0; i < n; i++) {
if (list[i].type == G_TYPE_DOUBLE || list[i].type == G_TYPE_ENUM || list[i].type == G_TYPE_PARAM) {
tarray[i] = G_TYPE_STRING;
} else {
tarray[i] = list[i].type;
}
list[i].edited_id = 0;
}
if (tree) {
lstore = GTK_TREE_MODEL(gtk_tree_store_newv(n, tarray));
} else {
lstore = GTK_TREE_MODEL(gtk_list_store_newv(n, tarray));
}
g_free(tarray);
tview = gtk_tree_view_new_with_model(lstore);
#if ! GTK_CHECK_VERSION(3, 14, 0)
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tview), TRUE);
#endif
gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(tview), TRUE);
gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(tview), GTK_TREE_VIEW_GRID_LINES_VERTICAL);
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tview));
gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
for (i = 0; i < n; i++) {
if (list[i].visible) {
col = create_column(list, i);
gtk_tree_view_column_set_visible(col, list[i].visible);
gtk_tree_view_append_column(GTK_TREE_VIEW(tview), col);
}
}
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tview), n > 1);
return tview;
}
static GtkTreeViewColumn *
add_column(GtkTreeView *tv, int column_id, const char *title, gfloat xalign,
GtkCellRenderer *renderer, GtkTreeCellDataFunc cell_data_func)
{
GtkTreeViewColumn *column;
column = create_column(column_id, title, xalign, renderer, cell_data_func);
configure_column(column);
gtk_tree_view_column_set_sort_column_id(column, column_id);
gtk_tree_view_append_column(tv, column);
return column;
}
void test_find_one() {
// Create a table and insert rows.
auto db = grnxx::open_db("");
auto table = db->create_table("Table");
table->insert_row();
table->insert_row();
table->insert_row();
auto column = table->create_column("Int", GRNXX_INT);
assert(column->find_one(grnxx::Int(123)).is_na());
assert(column->find_one(grnxx::Int(456)).is_na());
assert(column->find_one(grnxx::Int(789)).is_na());
assert(!column->find_one(grnxx::Int::na()).is_na());
column->set(grnxx::Int(0), grnxx::Int(123));
assert(!column->find_one(grnxx::Int(123)).is_na());
assert(column->find_one(grnxx::Int(456)).is_na());
assert(column->find_one(grnxx::Int(789)).is_na());
assert(!column->find_one(grnxx::Int::na()).is_na());
column->set(grnxx::Int(1), grnxx::Int(456));
assert(!column->find_one(grnxx::Int(123)).is_na());
assert(!column->find_one(grnxx::Int(456)).is_na());
assert(column->find_one(grnxx::Int(789)).is_na());
assert(!column->find_one(grnxx::Int::na()).is_na());
column->set(grnxx::Int(2), grnxx::Int(789));
assert(!column->find_one(grnxx::Int(123)).is_na());
assert(!column->find_one(grnxx::Int(456)).is_na());
assert(!column->find_one(grnxx::Int(789)).is_na());
assert(column->find_one(grnxx::Int::na()).is_na());
column->create_index("Index", GRNXX_TREE_INDEX);
assert(!column->find_one(grnxx::Int(123)).is_na());
assert(!column->find_one(grnxx::Int(456)).is_na());
assert(!column->find_one(grnxx::Int(789)).is_na());
assert(column->find_one(grnxx::Int::na()).is_na());
column->set(grnxx::Int(2), grnxx::Int::na());
assert(!column->find_one(grnxx::Int(123)).is_na());
assert(!column->find_one(grnxx::Int(456)).is_na());
assert(column->find_one(grnxx::Int(789)).is_na());
assert(!column->find_one(grnxx::Int::na()).is_na());
column->set(grnxx::Int(1), grnxx::Int::na());
assert(!column->find_one(grnxx::Int(123)).is_na());
assert(column->find_one(grnxx::Int(456)).is_na());
assert(column->find_one(grnxx::Int(789)).is_na());
assert(!column->find_one(grnxx::Int::na()).is_na());
column->set(grnxx::Int(0), grnxx::Int::na());
assert(column->find_one(grnxx::Int(123)).is_na());
assert(column->find_one(grnxx::Int(456)).is_na());
assert(column->find_one(grnxx::Int(789)).is_na());
assert(!column->find_one(grnxx::Int::na()).is_na());
}
void test_reference() {
// Create tables.
auto db = grnxx::open_db("");
auto to_table = db->create_table("To");
auto from_table = db->create_table("From");
// Create a column named "Ref".
grnxx::ColumnOptions options;
options.reference_table_name = "To";
auto ref_column = from_table->create_column("Ref", GRNXX_INT, options);
// Append rows.
to_table->insert_row();
to_table->insert_row();
to_table->insert_row();
from_table->insert_row();
from_table->insert_row();
from_table->insert_row();
ref_column->set(grnxx::Int(0), grnxx::Int(0));
ref_column->set(grnxx::Int(1), grnxx::Int(1));
ref_column->set(grnxx::Int(2), grnxx::Int(1));
// TODO: "from_table" may be updated in "to_table->remove_row()".
to_table->remove_row(grnxx::Int(0));
grnxx::Datum datum;
ref_column->get(grnxx::Int(0), &datum);
assert(datum.type() == GRNXX_INT);
assert(datum.as_int().raw() == 0);
ref_column->get(grnxx::Int(1), &datum);
assert(datum.type() == GRNXX_INT);
assert(datum.as_int().raw() == 1);
ref_column->get(grnxx::Int(2), &datum);
assert(datum.type() == GRNXX_INT);
assert(datum.as_int().raw() == 1);
to_table->remove_row(grnxx::Int(1));
ref_column->get(grnxx::Int(0), &datum);
assert(datum.type() == GRNXX_INT);
assert(datum.as_int().raw() == 0);
ref_column->get(grnxx::Int(1), &datum);
assert(datum.type() == GRNXX_INT);
assert(datum.as_int().raw() == 1);
ref_column->get(grnxx::Int(2), &datum);
assert(datum.type() == GRNXX_INT);
assert(datum.as_int().raw() == 1);
}
TbBool create_columns_from_list(struct Column *cols, long ccount)
{
struct Column *colmn;
long ncol;
long i;
for (i=1; i < ccount; i++)
{
if (cols[i].use)
{
ncol = find_column(&cols[i]);
if (ncol == 0)
ncol = create_column(&cols[i]);
colmn = get_column(ncol);
colmn->bitfields |= 0x01;
}
}
return true;
}
TbBool update_slabset_column_indices(struct Column *cols, long ccount)
{
struct Column *colmn;
struct Column lcolmn;
struct SlabSet *sset;
long ncol;
long i,k,n;
LbMemorySet(&lcolmn,0,sizeof(struct Column));
for (i=0; i < game.slabset_num; i++)
{
sset = &game.slabset[i];
for (k=0; k < 9; k++)
{
n = sset->col_idx[k];
if (n >= 0)
{
lcolmn.baseblock = n;
ncol = find_column(&lcolmn);
if (ncol == 0)
{
ncol = create_column(&lcolmn);
colmn = get_column(ncol);
colmn->bitfields |= 0x01;
}
} else
{
if (-n < ccount)
ncol = find_column(&cols[-n]);
else
ncol = 0;
if (ncol == 0)
{
ERRORLOG("E14R432Q#222564-3; I should be able to find a column here");
continue;
}
}
sset->col_idx[k] = -ncol;
}
}
return true;
}
void test_contains_and_find_one() {
constexpr size_t NUM_ROWS = 1 << 10;
// Create a table and insert the first row.
auto db = grnxx::open_db("");
auto table = db->create_table("Table");
auto column = table->create_column("Column", T::type());
grnxx::Array<T> values;
values.resize(NUM_ROWS);
for (size_t i = 0; i < NUM_ROWS; ++i) {
generate_random_value(&values[i]);
grnxx::Int row_id = table->insert_row();
column->set(row_id, values[i]);
}
// Test all the values.
for (size_t i = 0; i < NUM_ROWS; ++i) {
assert(column->contains(values[i]));
grnxx::Int row_id = column->find_one(values[i]);
assert(!row_id.is_na());
assert(values[i].match(values[row_id.raw()]));
}
// Test all the values with index if available.
try {
column->create_index("Index", GRNXX_TREE_INDEX);
for (size_t i = 0; i < NUM_ROWS; ++i) {
assert(column->contains(values[i]));
grnxx::Int row_id = column->find_one(values[i]);
assert(!row_id.is_na());
assert(values[i].match(values[row_id.raw()]));
}
column->remove_index("Index");
} catch (...) {
}
// Remove N/A values.
for (size_t i = 0; i < NUM_ROWS; ++i) {
if (values[i].is_na()) {
table->remove_row(grnxx::Int(i));
}
}
// Test all the values.
for (size_t i = 0; i < NUM_ROWS; ++i) {
if (!values[i].is_na()) {
assert(column->contains(values[i]));
grnxx::Int row_id = column->find_one(values[i]);
assert(!row_id.is_na());
assert(values[i].match(values[row_id.raw()]));
}
}
assert(!column->contains(T::na()));
assert(column->find_one(T::na()).is_na());
// Test all the values with index if available.
try {
column->create_index("Index", GRNXX_TREE_INDEX);
for (size_t i = 0; i < NUM_ROWS; ++i) {
if (!values[i].is_na()) {
assert(column->contains(values[i]));
grnxx::Int row_id = column->find_one(values[i]);
assert(!row_id.is_na());
assert(values[i].match(values[row_id.raw()]));
}
}
assert(!column->contains(T::na()));
assert(column->find_one(T::na()).is_na());
column->remove_index("Index");
} catch (...) {
}
// Insert a trailing N/A value.
table->insert_row_at(grnxx::Int(NUM_ROWS));
assert(column->contains(T::na()));
assert(column->find_one(T::na()).match(grnxx::Int(NUM_ROWS)));
try {
column->create_index("Index", GRNXX_TREE_INDEX);
assert(column->contains(T::na()));
assert(column->find_one(T::na()).match(grnxx::Int(NUM_ROWS)));
column->remove_index("Index");
} catch (...) {
}
// Remove non-N/A values.
for (size_t i = 0; i < NUM_ROWS; ++i) {
if (!values[i].is_na()) {
table->remove_row(grnxx::Int(i));
}
}
// Test all the values.
for (size_t i = 0; i < NUM_ROWS; ++i) {
if (!values[i].is_na()) {
assert(!column->contains(values[i]));
assert(column->find_one(values[i]).is_na());
}
}
assert(column->contains(T::na()));
assert(column->find_one(T::na()).match(grnxx::Int(NUM_ROWS)));
// Test all the values with index if available.
try {
column->create_index("Index", GRNXX_TREE_INDEX);
for (size_t i = 0; i < NUM_ROWS; ++i) {
if (!values[i].is_na()) {
assert(!column->contains(values[i]));
assert(column->find_one(values[i]).is_na());
}
}
assert(column->contains(T::na()));
assert(column->find_one(T::na()).match(grnxx::Int(NUM_ROWS)));
column->remove_index("Index");
} catch (...) {
}
}
wxSizer* create_column(const std::vector<SizerItem>& items){
return create_column(OuterSpacing(ui::panel_padding), ui::item_spacing, items);
}
void test_scored_subexpression() {
// Create a database with the default options.
auto db = grnxx::open_db("");
// Create a table with the default options.
auto table = db->create_table("Table");
constexpr size_t NUM_ROWS = 1 << 16;
// Generate random values.
grnxx::Array<grnxx::Float> float_values;
grnxx::Array<grnxx::Int> ref_values;
float_values.resize(NUM_ROWS);
ref_values.resize(NUM_ROWS);
for (size_t i = 0; i < NUM_ROWS; ++i) {
float_values[i] = grnxx::Float(1.0 * rng() / rng.max());
// ref_values[i] = mersenne_twister() % NUM_ROWS;
ref_values[i] = grnxx::Int(0);
}
// Create columns for Float and Int values.
auto float_column = table->create_column("Float", GRNXX_FLOAT);
grnxx::ColumnOptions options;
options.reference_table_name = "Table";
auto ref_column = table->create_column("Ref", GRNXX_INT, options);
// Store generated values into columns.
for (size_t i = 0; i < NUM_ROWS; ++i) {
grnxx::Int row_id = table->insert_row();
assert(row_id.match(grnxx::Int(i)));
float_column->set(row_id, float_values[i]);
}
for (size_t i = 0; i < NUM_ROWS; ++i) {
ref_column->set(grnxx::Int(i), ref_values[i]);
}
// Generate a list of records.
grnxx::Array<grnxx::Record> records;
auto cursor = table->create_cursor();
assert(cursor->read_all(&records) == table->num_rows());
// Set scores (Float).
auto builder = grnxx::ExpressionBuilder::create(table);
builder->push_column("Float");
auto expression = builder->release();
expression->adjust(&records);
// Test an expression (Ref.(_score > 0.5)).
builder->push_column("Ref");
builder->begin_subexpression();
builder->push_score();
builder->push_constant(grnxx::Float(0.5));
builder->push_operator(GRNXX_GREATER);
builder->end_subexpression();
expression = builder->release();
expression->filter(&records);
size_t count = 0;
for (size_t i = 0; i < NUM_ROWS; ++i) {
if (float_values[i].raw() > 0.5) {
assert(records[count].row_id.match(grnxx::Int(i)));
++count;
}
}
assert(records.size() == count);
}
void test_table() {
// Create a database with the default options.
auto db = grnxx::open_db("");
// Create a table named "Table".
auto table = db->create_table("Table");
assert(table->db() == db.get());
assert(table->name() == "Table");
assert(table->num_columns() == 0);
assert(!table->key_column());
assert(table->num_rows() == 0);
assert(table->max_row_id().is_na());
assert(table->is_empty());
assert(table->is_full());
// Create a column named "Column_1".
auto column = table->create_column("Column_1", GRNXX_BOOL);
assert(column->name() == "Column_1");
assert(table->num_columns() == 1);
assert(table->get_column(0) == column);
assert(table->find_column("Column_1") == column);
// The following create_column() must fail because "Column_1" already exists.
try {
table->create_column("Column_1", GRNXX_BOOL);
assert(false);
} catch (...) {
}
// Create columns named "Column_2" and Column_3".
table->create_column("Column_2", GRNXX_BOOL);
table->create_column("Column_3", GRNXX_BOOL);
assert(table->num_columns() == 3);
// Remove "Column_2".
table->remove_column("Column_2");
assert(table->num_columns() == 2);
assert(table->get_column(0)->name() == "Column_1");
assert(table->get_column(1)->name() == "Column_3");
// Recreate "Column_2".
table->create_column("Column_2", GRNXX_BOOL);
// Move "Column_3" to the next to "Column_2".
table->reorder_column("Column_3", "Column_2");
assert(table->get_column(0)->name() == "Column_1");
assert(table->get_column(1)->name() == "Column_2");
assert(table->get_column(2)->name() == "Column_3");
// Move "Column_3" to the head.
table->reorder_column("Column_3", "");
assert(table->get_column(0)->name() == "Column_3");
assert(table->get_column(1)->name() == "Column_1");
assert(table->get_column(2)->name() == "Column_2");
// Move "Column_2" to the next to "Column3".
table->reorder_column("Column_2", "Column_3");
assert(table->get_column(0)->name() == "Column_3");
assert(table->get_column(1)->name() == "Column_2");
assert(table->get_column(2)->name() == "Column_1");
}
void test_int_key() {
// Create a table named "Table".
auto db = grnxx::open_db("");
auto table = db->create_table("Table");
// Create a column named "Column".
auto column = table->create_column("Column", GRNXX_INT);
// Append three rows.
grnxx::Int row_id = table->insert_row();
column->set(row_id, grnxx::Int(1));
row_id = table->insert_row();
column->set(row_id, grnxx::Int(10));
row_id = table->insert_row();
column->set(row_id, grnxx::Int(100));
// Set key column.
table->set_key_column("Column");
assert(table->key_column() == column);
// Duplicate keys must be rejected.
bool inserted = true;
row_id = table->find_or_insert_row(grnxx::Int(1), &inserted);
assert(row_id.match(grnxx::Int(0)));
assert(!inserted);
row_id = table->find_or_insert_row(grnxx::Int(10), &inserted);
assert(row_id.match(grnxx::Int(1)));
assert(!inserted);
row_id = table->find_or_insert_row(grnxx::Int(100), &inserted);
assert(row_id.match(grnxx::Int(2)));
assert(!inserted);
// Append new keys.
grnxx::Datum datum;
row_id = table->find_or_insert_row(grnxx::Int(2), &inserted);
assert(inserted);
column->get(row_id, &datum);
assert(datum.as_int().raw() == 2);
row_id = table->find_or_insert_row(grnxx::Int(20), &inserted);
column->get(row_id, &datum);
assert(datum.as_int().raw() == 20);
row_id = table->find_or_insert_row(grnxx::Int(200), &inserted);
column->get(row_id, &datum);
assert(datum.as_int().raw() == 200);
row_id = table->find_or_insert_row(grnxx::Int(200000), &inserted);
column->get(row_id, &datum);
assert(datum.as_int().raw() == 200000);
row_id = table->find_or_insert_row(grnxx::Int(20000000000L), &inserted);
column->get(row_id, &datum);
assert(datum.as_int().raw() == 20000000000L);
// Find rows by key.
assert(table->find_row(grnxx::Int(1)).raw() == 0);
assert(table->find_row(grnxx::Int(10)).raw() == 1);
assert(table->find_row(grnxx::Int(100)).raw() == 2);
assert(table->find_row(grnxx::Int(2)).raw() == 3);
assert(table->find_row(grnxx::Int(20)).raw() == 4);
assert(table->find_row(grnxx::Int(200)).raw() == 5);
assert(table->find_row(grnxx::Int(200000)).raw() == 6);
assert(table->find_row(grnxx::Int(20000000000L)).raw() == 7);
assert(table->find_row(grnxx::Int::na()).is_na());
// Unset key column.
table->unset_key_column();
assert(!table->key_column());
// Test an N/A value.
column->set(grnxx::Int(0), grnxx::Int::na());
try {
table->set_key_column("Column");
assert(false);
} catch (...) {
}
// Test a trailing N/A value.
table->insert_row();
try {
table->set_key_column("Column");
assert(false);
} catch (...) {
}
}
/*
* create variables tree view widget
* arguments:
* on_render_name - custom name column renderer function
* on_expression_changed - callback to call on expression changed
*/
GtkWidget* vtree_create(watch_render_name on_render_name, watch_expression_changed on_expression_changed)
{
/* create tree view */
GtkTreeStore* store = gtk_tree_store_new (
W_N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_INT);
GtkWidget* tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store));
/* set tree view parameters */
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_grid_lines (GTK_TREE_VIEW(tree), GTK_TREE_VIEW_GRID_LINES_VERTICAL);
g_object_set(tree, "rules-hint", TRUE, NULL);
/* connect signals */
g_signal_connect(G_OBJECT(tree), "row-collapsed", G_CALLBACK (on_row_collapsed), NULL);
g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK (on_key_pressed), NULL);
/* create columns */
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
gchar *header;
int char_width = get_char_width(tree);
/* Name */
header = _("Name");
renderer = gtk_cell_renderer_text_new ();
column = create_column(header, renderer, FALSE,
get_header_string_width(header, MW_NAME, char_width),
"text", W_NAME);
if (on_render_name)
gtk_tree_view_column_set_cell_data_func(column, renderer, on_render_name, NULL, NULL);
if (on_expression_changed)
{
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (on_expression_changed), NULL);
}
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Value */
header = _("Value");
renderer = gtk_cell_renderer_text_new ();
column = create_column(header, renderer, TRUE,
get_header_string_width(header, MW_VALUE, char_width),
"text", W_VALUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, render_value, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Type */
header = _("Type");
renderer = gtk_cell_renderer_text_new ();
column = create_column(header, renderer, FALSE,
get_header_string_width(header, MW_TYPE, char_width),
"text", W_TYPE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Internal (unvisible column) */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Internal", renderer, "text", W_INTERNAL, NULL);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Path expression (unvisible column) */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Expression", renderer, "text", W_EXPRESSION, NULL);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* STUB (unvisible column) */
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes ("Need Update", renderer, "active", W_STUB, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
gtk_tree_view_column_set_visible(column, FALSE);
/* Changed (unvisible column) */
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes ("Changed", renderer, "active", W_CHANGED, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
gtk_tree_view_column_set_visible(column, FALSE);
return tree;
}
void test_internal_type_conversion() {
// Create a table and insert rows.
auto db = grnxx::open_db("");
auto table = db->create_table("Table");
table->insert_row();
table->insert_row();
table->insert_row();
table->insert_row();
auto column = table->create_column("Column", GRNXX_INT);
// Set the first 8-bit integer.
column->set(grnxx::Int(0), grnxx::Int(int64_t(1) << 0));
grnxx::Datum datum;
column->get(grnxx::Int(0), &datum);
assert(datum.as_int().raw() == (int64_t(1) << 0));
// Conversion from 8-bit to 16-bit.
column->set(grnxx::Int(1), grnxx::Int(int64_t(1) << 8));
column->get(grnxx::Int(0), &datum);
assert(datum.as_int().raw() == (int64_t(1) << 0));
column->get(grnxx::Int(1), &datum);
assert(datum.as_int().raw() == (int64_t(1) << 8));
// Conversion from 16-bit to 32-bit.
column->set(grnxx::Int(2), grnxx::Int(int64_t(1) << 16));
column->get(grnxx::Int(0), &datum);
assert(datum.as_int().raw() == (int64_t(1) << 0));
column->get(grnxx::Int(1), &datum);
assert(datum.as_int().raw() == (int64_t(1) << 8));
column->get(grnxx::Int(2), &datum);
assert(datum.as_int().raw() == (int64_t(1) << 16));
// Conversion from 32-bit to 64-bit.
column->set(grnxx::Int(3), grnxx::Int(int64_t(1) << 32));
column->get(grnxx::Int(0), &datum);
assert(datum.as_int().raw() == (int64_t(1) << 0));
column->get(grnxx::Int(1), &datum);
assert(datum.as_int().raw() == (int64_t(1) << 8));
column->get(grnxx::Int(2), &datum);
assert(datum.as_int().raw() == (int64_t(1) << 16));
column->get(grnxx::Int(3), &datum);
assert(datum.as_int().raw() == (int64_t(1) << 32));
table->remove_column("Column");
column = table->create_column("Column", GRNXX_INT);
// Conversion from 8-bit to 32-bit.
column->set(grnxx::Int(0), grnxx::Int(int64_t(1) << 0));
column->set(grnxx::Int(1), grnxx::Int(int64_t(1) << 16));
column->get(grnxx::Int(0), &datum);
assert(datum.as_int().raw() == (int64_t(1) << 0));
column->get(grnxx::Int(1), &datum);
assert(datum.as_int().raw() == (int64_t(1) << 16));
table->remove_column("Column");
column = table->create_column("Column", GRNXX_INT);
// Conversion from 8-bit to 64-bit.
column->set(grnxx::Int(0), grnxx::Int(int64_t(1) << 0));
column->set(grnxx::Int(1), grnxx::Int(int64_t(1) << 32));
column->get(grnxx::Int(0), &datum);
assert(datum.as_int().raw() == (int64_t(1) << 0));
column->get(grnxx::Int(1), &datum);
assert(datum.as_int().raw() == (int64_t(1) << 32));
table->remove_column("Column");
column = table->create_column("Column", GRNXX_INT);
// Conversion from 16-bit to 64-bit.
column->set(grnxx::Int(0), grnxx::Int(int64_t(1) << 8));
column->set(grnxx::Int(1), grnxx::Int(int64_t(1) << 32));
column->get(grnxx::Int(0), &datum);
assert(datum.as_int().raw() == (int64_t(1) << 8));
column->get(grnxx::Int(1), &datum);
assert(datum.as_int().raw() == (int64_t(1) << 32));
}
/*
* create target page
*/
void tpage_init()
{
page = gtk_hbox_new(FALSE, 0);
GtkWidget *lbox = gtk_vbox_new(FALSE, SPACING);
GtkWidget *mbox = gtk_vbox_new(FALSE, SPACING);
GtkWidget *rbox = gtk_vbox_new(FALSE, SPACING);
GtkWidget* separator = gtk_vseparator_new();
/* right box with Load/Save buttons */
gtk_container_set_border_width(GTK_CONTAINER(rbox), SPACING);
loadbtn = gtk_button_new_from_stock(GTK_STOCK_OPEN);
g_signal_connect(G_OBJECT(loadbtn), "clicked", G_CALLBACK (on_load_config), (gpointer)TRUE);
savebtn = gtk_button_new_from_stock(GTK_STOCK_SAVE);
g_signal_connect(G_OBJECT(savebtn), "clicked", G_CALLBACK (on_save_config), NULL);
clearbtn = gtk_button_new_from_stock(GTK_STOCK_CLEAR);
g_signal_connect(G_OBJECT(clearbtn), "clicked", G_CALLBACK (on_clear), NULL);
gtk_box_pack_start(GTK_BOX(rbox), loadbtn, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(rbox), savebtn, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(rbox), clearbtn, FALSE, TRUE, 0);
GtkWidget *hombox = gtk_hbox_new(TRUE, 0);
/* left box */
gtk_container_set_border_width(GTK_CONTAINER(lbox), SPACING);
/* Target frame */
GtkWidget *frame = gtk_frame_new(_("Target"));
GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
/* filename hbox */
GtkWidget *hbox = gtk_hbox_new(FALSE, SPACING);
gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING);
targetname = gtk_entry_new ();
button_browse = gtk_button_new_with_label(_("Browse"));
g_signal_connect(G_OBJECT(button_browse), "clicked", G_CALLBACK (on_target_browse_clicked), NULL);
gtk_box_pack_start(GTK_BOX(hbox), targetname, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), button_browse, FALSE, TRUE, 0);
/* pack in the vertical box */
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
/* debugger type hbox */
hbox = gtk_hbox_new(FALSE, SPACING);
gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING);
GtkWidget *label = gtk_label_new(_("Debugger:"));
cmb_debugger = gtk_combo_box_new_text();
GList *modules = debug_get_modules();
GList *iter = modules;
while (iter)
{
gtk_combo_box_append_text(GTK_COMBO_BOX(cmb_debugger), (gchar*)iter->data);
iter = iter->next;
}
g_list_free(modules);
gtk_combo_box_set_active(GTK_COMBO_BOX(cmb_debugger), 0);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), cmb_debugger, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox);
gtk_box_pack_start(GTK_BOX(lbox), frame, FALSE, FALSE, 0);
/* Arguments frame */
frame = gtk_frame_new(_("Arguments"));
hbox = gtk_vbox_new(FALSE, SPACING);
gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING);
textview = gtk_text_view_new ();
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_CHAR);
gtk_box_pack_start(GTK_BOX(hbox), textview, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(frame), hbox);
gtk_box_pack_start(GTK_BOX(lbox), frame, TRUE, TRUE, 0);
/* Environment */
gtk_container_set_border_width(GTK_CONTAINER(mbox), SPACING);
frame = gtk_frame_new(_("Environment variables"));
hbox = gtk_hbox_new(FALSE, SPACING);
gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING);
store = gtk_list_store_new (
N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING);
model = GTK_TREE_MODEL(store);
envtree = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(envtree), TRUE);
gtk_tree_view_set_grid_lines (GTK_TREE_VIEW(envtree), GTK_TREE_VIEW_GRID_LINES_VERTICAL);
g_object_set(envtree, "rules-hint", TRUE, NULL);
g_signal_connect(G_OBJECT(envtree), "key-press-event", G_CALLBACK (on_envtree_keypressed), NULL);
gchar *header;
int char_width = get_char_width(envtree);
header = _("Name");
renderer_name = gtk_cell_renderer_text_new ();
g_object_set (renderer_name, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (renderer_name), "edited", G_CALLBACK (on_name_changed), NULL);
column_name = create_column(header, renderer_name, FALSE,
get_header_string_width(header, MW_NAME, char_width),
"text", NAME);
gtk_tree_view_append_column (GTK_TREE_VIEW (envtree), column_name);
header = _("Value");
renderer_value = gtk_cell_renderer_text_new ();
column_value = create_column(header, renderer_value, TRUE,
get_header_string_width(header, MW_VALUE, char_width),
"text", VALUE);
g_signal_connect (G_OBJECT (renderer_value), "edited", G_CALLBACK (on_value_changed), NULL);
g_signal_connect (G_OBJECT (renderer_value), "editing-started", G_CALLBACK (on_value_editing_started), NULL);
g_signal_connect (G_OBJECT (renderer_value), "editing-canceled", G_CALLBACK (on_value_editing_cancelled), NULL);
gtk_tree_view_column_set_cell_data_func(column_value, renderer_value, on_render_value, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (envtree), column_value);
/* add empty row */
add_empty_row();
/* set multiple selection */
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(envtree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_box_pack_start(GTK_BOX(hbox), envtree, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(frame), hbox);
gtk_box_pack_start(GTK_BOX(mbox), frame, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hombox), lbox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hombox), mbox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(page), hombox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(page), separator, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(page), rbox, FALSE, TRUE, 0);
/* update Load/Save config button */
tpage_on_document_activate(document_get_current());
}
