END_TEST
START_TEST (test_append)
{
printf("\n************************\n");
printf("* Test for append_row *\n");
printf("************************\n");
printf("\nArrange... \n");
int all_data[4][4];
address all_data_addr = all_data;
int row_data[4] = { 10, 20, 30, 40 };
address row_data_addr = row_data;
int row_index = 2;
int width = 4;
printf("\nAct... \n");
append_row(all_data_addr, row_data_addr, row_index, width);
printf("\nAssert... \n");
int i = 0;
for(i = 0; i < width; i++)
{
fail_unless(all_data[row_index][i] == row_data[i],
"Expected all_data[%d][%d] to be %d @ row_data[%d]",
row_index, i, row_data[i], i);
}
/* Reset */
printf("\n********* PASS *********\n");
}
static void
glade_eprop_model_data_add_row (GladeEditorProperty * eprop)
{
GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);
GValue value = { 0, };
GNode *node = NULL;
GList *columns = NULL;
GladeProperty *property = glade_editor_property_get_property (eprop);
glade_property_get (property, &node);
glade_widget_property_get (glade_property_get_widget (property), "columns", &columns);
if (!columns)
return;
clear_view (eprop);
if (!node)
node = g_node_new (NULL);
else
node = glade_model_data_tree_copy (node);
append_row (node, columns);
eprop_data->adding_row = TRUE;
g_value_init (&value, GLADE_TYPE_MODEL_DATA_TREE);
g_value_take_boxed (&value, node);
glade_editor_property_commit (eprop, &value);
g_value_unset (&value);
eprop_data->adding_row = FALSE;
}
int32_t ExportSubstep::Execute(TableManager *table, MileHandler *handler, void *output, MEM_POOL_PTR mem_pool)
{
int64_t *export_num = (int64_t *)output;
if (limit_ > 0 && *export_num >= limit_) {
// break MainStep's loop.
return WARN_EXCEED_QUERY_LIMIT;
}
out_buf_.clear();
out_buf_.append("INSERT INTO ");
out_buf_.append(table_name_);
struct row_data *row = table->GetRowData(handler, mem_pool);
if (!row) {
log_error("No row value");
return -1;
}
int rc = append_row(&out_buf_, row);
if (rc)
return -1;
out_buf_.append("\n");
rc = unintr_write(fd_, out_buf_.data(), out_buf_.size());
if (rc < 0 || (size_t)rc != out_buf_.size()) {
log_error("write to %s failed, errno %d", path_, errno);
return -1;
}
(*export_num)++;
return 0;
}
static void
add_button_click_cb (GtkWidget *button,
RBQueryCreator *creator)
{
append_row (creator);
}
static gboolean
rb_query_creator_load_query (RBQueryCreator *creator,
GPtrArray *query,
RhythmDBQueryModelLimitType limit_type,
GVariant *limit_value)
{
RBQueryCreatorPrivate *priv = QUERY_CREATOR_GET_PRIVATE (creator);
int i;
GList *rows;
gboolean disjunction = FALSE;
RhythmDBQueryData *qdata;
GPtrArray *subquery;
guint64 limit;
g_return_val_if_fail (query->len == 2, FALSE);
qdata = g_ptr_array_index (query, 1);
g_return_val_if_fail (qdata->type == RHYTHMDB_QUERY_SUBQUERY, FALSE);
subquery = qdata->subquery;
if (subquery->len > 0) {
for (i = 0; i < subquery->len; i++) {
RhythmDBQueryData *data = g_ptr_array_index (subquery, i);
if (data->type != RHYTHMDB_QUERY_DISJUNCTION)
append_row (creator);
}
}
rows = priv->rows;
for (i = 0; i < subquery->len; i++) {
RhythmDBQueryData *data = g_ptr_array_index (subquery, i);
GtkComboBox *propmenu;
GtkWidget *criteria_menu;
int index;
const RBQueryCreatorPropertyType *property_type;
if (data->type == RHYTHMDB_QUERY_DISJUNCTION) {
disjunction = TRUE;
continue;
}
propmenu = GTK_COMBO_BOX (get_box_widget_at_pos (GTK_BOX (rows->data), 0));
index = get_property_index_from_proptype (property_options, num_property_options, data->propid);
gtk_combo_box_set_active (propmenu, index);
criteria_menu = get_box_widget_at_pos (GTK_BOX (rows->data), 1);
select_criteria_from_value (creator, criteria_menu, data->propid, data->type);
property_type = property_options[index].property_type;
g_assert (property_type->criteria_set_widget_data != NULL);
property_type->criteria_set_widget_data (get_box_widget_at_pos (GTK_BOX (rows->data), 2),
data->val);
rows = rows->next;
}
/* setup the limits */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->disjunction_check),
disjunction);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->limit_check),
limit_type != RHYTHMDB_QUERY_MODEL_LIMIT_NONE);
switch (limit_type) {
case RHYTHMDB_QUERY_MODEL_LIMIT_NONE:
limit = 0;
break;
case RHYTHMDB_QUERY_MODEL_LIMIT_COUNT:
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->limit_option), 0);
limit = g_variant_get_uint64 (limit_value);
break;
case RHYTHMDB_QUERY_MODEL_LIMIT_TIME:
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->limit_option), 3);
/* convert to minutes */
limit = g_variant_get_uint64 (limit_value) / 60;
break;
case RHYTHMDB_QUERY_MODEL_LIMIT_SIZE:
limit = g_variant_get_uint64 (limit_value);
if (limit % 1000 == 0) {
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->limit_option), 2);
limit /= 1000;
} else {
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->limit_option), 1);
}
break;
default:
g_assert_not_reached ();
}
gtk_spin_button_set_value (GTK_SPIN_BUTTON (priv->limit_entry), limit);
return TRUE;
}
static void
rb_query_creator_constructed (GObject *object)
{
RBQueryCreatorPrivate *priv;
RBQueryCreator *creator;
GtkWidget *mainbox;
GtkWidget *content_area;
GtkBuilder *builder;
RB_CHAIN_GOBJECT_METHOD (rb_query_creator_parent_class, constructed, object);
creator = RB_QUERY_CREATOR (object);
priv = QUERY_CREATOR_GET_PRIVATE (creator);
if (priv->creating) {
gtk_dialog_add_button (GTK_DIALOG (creator),
_("_Cancel"),
GTK_RESPONSE_CLOSE);
gtk_dialog_add_button (GTK_DIALOG (creator),
_("_New"),
GTK_RESPONSE_OK);
} else {
gtk_dialog_add_button (GTK_DIALOG (creator),
_("_Close"),
GTK_RESPONSE_CLOSE);
}
gtk_dialog_set_default_response (GTK_DIALOG (creator),
GTK_RESPONSE_CLOSE);
priv->property_size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->criteria_size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->entry_size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->button_size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
if (priv->creating)
gtk_window_set_title (GTK_WINDOW (creator), _("Create Automatic Playlist"));
else
gtk_window_set_title (GTK_WINDOW (creator), _("Edit Automatic Playlist"));
content_area = gtk_dialog_get_content_area (GTK_DIALOG (creator));
gtk_container_set_border_width (GTK_CONTAINER (creator), 5);
gtk_box_set_spacing (GTK_BOX (content_area), 2);
builder = rb_builder_load ("create-playlist.ui", creator);
priv->disjunction_check = GTK_WIDGET (gtk_builder_get_object (builder, "disjunctionCheck"));
priv->limit_check = GTK_WIDGET (gtk_builder_get_object (builder, "limitCheck"));
priv->limit_entry = GTK_WIDGET (gtk_builder_get_object (builder, "limitEntry"));
priv->limit_option = GTK_WIDGET (gtk_builder_get_object (builder, "limitOption"));
priv->addbutton = GTK_WIDGET (gtk_builder_get_object (builder, "addButton"));
priv->sort_label = GTK_WIDGET (gtk_builder_get_object (builder, "sortLabel"));
priv->sort_menu = GTK_WIDGET (gtk_builder_get_object (builder, "sortMenu"));
priv->sort_desc = GTK_WIDGET (gtk_builder_get_object (builder, "sortDesc"));
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->limit_option), 0);
g_signal_connect_object (G_OBJECT (priv->limit_check), "toggled", G_CALLBACK (limit_toggled_cb),
creator, 0);
limit_toggled_cb (priv->limit_check, creator);
gtk_size_group_add_widget (priv->button_size_group, priv->addbutton);
g_signal_connect_object (G_OBJECT (priv->addbutton), "clicked", G_CALLBACK (add_button_click_cb),
creator, 0);
setup_sort_option_menu (creator, priv->sort_menu, sort_options, num_sort_options);
priv->vbox = GTK_BOX (gtk_builder_get_object (builder, "sub_vbox"));
if (priv->creating)
append_row (creator);
mainbox = GTK_WIDGET (gtk_builder_get_object (builder, "complex-playlist-creator"));
gtk_box_pack_start (GTK_BOX (content_area), mainbox, FALSE, FALSE, 0);
gtk_widget_show_all (GTK_WIDGET (creator));
g_object_unref (builder);
}
void process_constraint(const string& rel, const vector<mpq_class>& left, mpq_class right, const mpq_class modulus,
map <Type::InputType, vector< vector<mpq_class> > >& input_map, bool forced_hom) {
vector<mpq_class> row=left;
bool inhomogeneous=false;
if(right!=0 || rel=="<" || rel==">")
inhomogeneous=true;
string modified_rel=rel;
bool strict_inequality=false;
if(rel=="<"){
strict_inequality=true;
right-=1;
modified_rel="<=";
}
if(rel==">"){
strict_inequality=true;
right+=1;
modified_rel=">=";
}
if(strict_inequality && forced_hom){
throw BadInputException("Strict inequality not allowed in hom_constraints!");
}
if(inhomogeneous || forced_hom)
row.push_back(-right); // rhs --> lhs
if(modified_rel=="<="){ // convert <= to >=
for(size_t j=0; j<row.size();++j)
row[j]=-row[j];
modified_rel=">=";
}
if(rel=="~")
row.push_back(modulus);
if(inhomogeneous && !forced_hom){
if(modified_rel=="="){
append_row(row,input_map,Type::inhom_equations);
return;
}
if(modified_rel==">="){
append_row(row,input_map,Type::inhom_inequalities);
return;
}
if(modified_rel=="~"){
append_row(row,input_map,Type::inhom_congruences);
return;
}
}
else {
if(modified_rel=="="){
append_row(row,input_map,Type::equations);
return;
}
if(modified_rel==">="){
append_row(row,input_map,Type::inequalities);
return;
}
if(modified_rel=="~"){
append_row(row,input_map,Type::congruences);
return;
}
}
throw BadInputException("Illegal constrint type "+rel+" !");
}
