int store_element (char * question, int module_id, int atom_id, int clause_id, PrologElement * head) {
MYSQL_RES * result;
MYSQL_ROW row;
int ind, sub;
switch (head -> type) {
case 0: case 2: case 4: case 5: case 7: case 8: case 9:
sprintf (question, "insert into elements (module_id, atom_id, clause_id, type, reference, value) values (%i, %i, %i, %i, %i, %f)", module_id, atom_id, clause_id, head -> type, (head -> type == 8 || head -> type == 2) ? head -> getInteger () : 0, head -> type == 9 ? head -> getDouble () : 0.0);
if (mysql_query (connection, question) != 0) return -1;
ind = last_insert_id ();
return ind;
break;
case 1:
ind = store_element (question, module_id, atom_id, clause_id, head -> getLeft ());
sub = store_element (question, module_id, atom_id, clause_id, head -> getRight ());
sprintf (question, "insert into elements (module_id, atom_id, clause_id, type, reference, reference_right) values (%i, %i, %i, %i, %i, %i)", module_id, atom_id, clause_id, head -> type, ind, sub);
if (mysql_query (connection, question) != 0) return -1;
return last_insert_id ();
break;
case 3:
sprintf (question, "insert into elements (module_id, atom_id, clause_id, type, reference) values (%i, %i, %i, %i, %i)", module_id, atom_id, clause_id, head -> type, find_or_create_atom (question, head -> getAtom ()));
if (mysql_query (connection, question) != 0) return -1;
return last_insert_id ();
break;
case 6:
sprintf (question, "insert into texts (module_id, atom_id, clause_id, text) values (%i, %i, %i, '%s')", module_id, atom_id, clause_id, head -> getText ());
if (mysql_query (connection, question) != 0) return -1;
sprintf (question, "insert into elements (module_id, atom_id, clause_id, type, reference) values (%i, %i, %i, %i, %i)", module_id, atom_id, clause_id, head -> type, last_insert_id ());
if (mysql_query (connection, question) != 0) return -1;
return last_insert_id ();
break;
default: break;
}
return -1;
}
int insert_model(void* model, const char* stmt) {
struct model* m = model;
if(query(stmt) == 0) {
m->id_ul = last_insert_id();
sprintf(m->id, "%lu", m->id_ul);
return 0;
}
else {
return -1;
}
}
virtual bool code (PrologElement * parameters, PrologResolution * resolution) {
if (parameters -> isEarth ()) {
delete this;
return true;
}
if (! parameters -> isPair ()) return false;
PrologElement * a = parameters -> getLeft ();
if (! a -> isAtom ()) return false;
parameters = parameters -> getRight ();
PrologAtom * control_atom = a -> getAtom ();
AREA question;
if (control_atom == sql_atom) {
if (! parameters -> isPair ()) return false;
PrologElement * q = parameters -> getLeft ();
if (! q -> isText ()) return false;
parameters = parameters -> getRight ();
if (mysql_query (connection, q -> getText ()) != 0) return false;
MYSQL_RES * result = mysql_use_result (connection);
if (result == NULL) return true;
MYSQL_ROW row;
int num_fields = mysql_num_fields (result);
parameters -> setEarth ();
while ((row = mysql_fetch_row (result)) != 0) {
parameters -> setPair ();
PrologElement * head = parameters -> getLeft ();
for (int ind = 0; ind < num_fields; ind++) {
head -> setPair ();
if (row [ind] != NULL) {
head -> getLeft () -> setText (row [ind]);
}
head = head -> getRight ();
}
parameters = parameters -> getRight ();
}
mysql_free_result (result);
return true;
}
if (control_atom == dbcl_atom) {
if (! parameters -> isPair ()) return false;
PrologElement * e = parameters -> getLeft ();
parameters = parameters -> getRight ();
if (e -> isText ()) {
if (! parameters -> isPair ()) return false;
PrologElement * atom = parameters -> getLeft ();
if (! atom -> isText ()) return false;
parameters = parameters -> getRight ();
if (parameters -> isVar ()) return read_number_of_clauses (parameters, e -> getText (), atom -> getText ());
if (! parameters -> isPair ()) return false;
PrologElement * ordering = parameters -> getLeft ();
if (ordering -> isVar ()) return read_number_of_clauses (ordering, e -> getText (), atom -> getText ());
if (! ordering -> isInteger ()) return false;
parameters = parameters -> getRight ();
if (parameters -> isEarth ()) return read_number_of_clauses (ordering, e -> getText (), atom -> getText ());
return read_clause (parameters, e -> getText (), atom -> getText (), ordering -> getInteger ());
}
if (e -> isAtom ()) {
PrologDirectory * dir = find_atoms_module (e -> getAtom ());
if (dir == NULL) return false;
if (parameters -> isVar ()) return read_number_of_clauses (parameters, dir -> name (), e -> getAtom () -> name ());
if (! parameters -> isPair ()) return false;
PrologElement * ordering = parameters -> getLeft ();
if (ordering -> isVar ()) return read_number_of_clauses (ordering, dir -> name (), e -> getAtom () -> name ());
if (! ordering -> isInteger ()) return false;
parameters = parameters -> getRight ();
if (parameters -> isEarth ()) return read_number_of_clauses (ordering, dir -> name (), e -> getAtom () -> name ());
return read_clause (parameters, dir -> name (), e -> getAtom () -> name (), ordering -> getInteger ());
}
return false;
}
if (control_atom == adbcl_atom || control_atom == adbcl0_atom) {
if (! parameters -> isPair ()) return false;
parameters = parameters -> getLeft ();
AREA drop;
if (fast) root -> getValue (parameters, drop, 0);
if (! parameters -> isPair ()) return false;
PrologElement * head = parameters -> getLeft ();
if (! head -> isPair ()) return false;
PrologElement * atom = head -> getLeft ();
if (! atom -> isAtom ()) return false;
MYSQL_RES * result;
MYSQL_ROW row;
PrologDirectory * dir = find_atoms_module (atom -> getAtom ());
// get the module_id and atom_id
int module_id = find_or_create_module (question, dir -> name ());
int atom_id = find_or_create_atom (question, atom -> getAtom ());
// now get the clause ordering
int ordering = 0;
if (control_atom == adbcl_atom) {
if (fast) sprintf (question, "select max(ordering) + 1 from text_clauses where module_id = %i and atom_id = %i", module_id, atom_id);
else sprintf (question, "select max(ordering) + 1 from clauses where module_id = %i and atom_id = %i", module_id, atom_id);
if (mysql_query (connection, question) != 0) return false;
result = mysql_use_result (connection);
if (result == NULL) return false;
if (mysql_num_fields (result) < 1) FAIL
if ((row = mysql_fetch_row (result)) == 0) FAIL
if (row [0] != NULL) ordering = atoi (row [0]);
mysql_free_result (result);
} else {
if (fast) sprintf (question, "update text_clauses set ordering = ordering + 1 where atom_id = %i", atom_id);
else sprintf (question, "update clauses set ordering = ordering + 1 where atom_id = %i", atom_id);
if (mysql_query (connection, question) != 0) return false;
}
// insert clause and get clause id
if (fast) {
sprintf (question, "insert into text_clauses (module_id, atom_id, ordering, text) values (%i, %i, %i, '%s')", module_id, atom_id, ordering, drop);
if (mysql_query (connection, question) != 0) {printf ("failed at text clause\n");}
return true;
}
sprintf (question, "insert into clauses (module_id, atom_id, ordering, parameters_id, body_id) values (%i, %i, %i, 0, 0)", module_id, atom_id, ordering);
if (mysql_query (connection, question) != 0) return false;
int clause_id = last_insert_id();
// now insert elements
int head_id = store_element (question, module_id, atom_id, clause_id, head -> getRight ());
int body_id = store_element (question, module_id, atom_id, clause_id, parameters -> getRight ());
sprintf (question, "update clauses set parameters_id = %i, body_id = %i where id = %i", head_id, body_id, clause_id);
if (mysql_query (connection, question) != 0) return false;
return true;
}
int create_atom (char * question, int module_id, char * atom_name) {
sprintf (question, "insert into atoms (module_id, atom) values (%i, '%s')", module_id, atom_name);
if (mysql_query (connection, question) != 0) return -1;
return last_insert_id ();
}
int create_module (char * question, char * module_name) {
sprintf (question, "insert into modules (module) values ('%s')", module_name);
if (mysql_query (connection, question) != 0) return -1;
return last_insert_id ();
}
size_t connection::run_prepared_insert_impl(prepared_statement_t& prepared_statement) {
execute_statement(prepared_statement.native_handle());
return last_insert_id();
}
size_t connection::insert_impl(const std::string& statement) {
auto prepared = prepare_statement(*_handle, statement);
execute_statement(prepared->stmt);
return last_insert_id();
}
