Statement *abc_create_expression_statement(Expression *expression){
Statement *st;
st = create_statement(EXPRESSION_STATEMENT);
st->u.expr_stat = expression;
fprintf(stderr, "expression statement\n");
return st;
}
Statement *abc_create_return_statement(Expression *expression) {
Statement *st;
st = create_statement(RETURN_STATEMENT);
st->u.return_stat.expr = expression;
return st;
}
Statement *abc_create_while_statement(Expression *cond, Block *block) {
Statement *stmt;
stmt = create_statement(WHILE_STATEMENT);
stmt->u.while_stat.cond = cond;
stmt->u.while_stat.block = block;
return stmt;
}
Statement *abc_create_for_statement(Expression *init, Expression *cond,
Expression *post, Block *block) {
Statement *stmt;
stmt = create_statement(FOR_STATEMENT);
stmt->u.for_stat.init = init;
stmt->u.for_stat.cond = cond;
stmt->u.for_stat.post = post;
stmt->u.for_stat.block = block;
return stmt;
}
Statement *abc_create_if_statement(Expression *if_cond, Block *if_block,
ElseIfList *elseif, Block *else_block) {
Statement *stmt;
stmt = create_statement(IF_STATEMENT);
stmt->u.if_stat.if_cond = if_cond;
stmt->u.if_stat.if_block = if_block;
stmt->u.if_stat.elseif = elseif;
stmt->u.if_stat.else_block = else_block;
return stmt;
}
static guint
request_execution (GdaConnection *cnc, const gchar *sql)
{
GdaStatement *stmt;
guint id;
GError *error = NULL;
g_print ("=========== Async. execution request:\n%s\n", sql);
stmt = create_statement (sql);
id = gda_connection_async_statement_execute (cnc, stmt, NULL, GDA_STATEMENT_MODEL_RANDOM_ACCESS, NULL, FALSE,
&error);
g_object_unref (stmt);
if (id == 0) {
g_print ("Can't execute ASYNC: %s\n", error && error->message ? error->message : "No detail");
exit (1);
}
g_print ("Assigned task id: %u\n", id);
return id;
}
/*
* ... is a list of (const gchar *name, const gchar *value) couples, terminated by %NULL
*/
static guint
request_execution_with_params (GdaConnection *cnc, const gchar *sql, ...)
{
GdaStatement *stmt;
guint id;
GError *error = NULL;
GdaSet *params;
const gchar *pname;
g_print ("=========== Async. exececution request:\n%s\n", sql);
stmt = create_statement (sql);
if (! gda_statement_get_parameters (stmt, ¶ms, &error)) {
g_print ("Can't get statement's parameters: %s\n", error && error->message ? error->message : "No detail");
exit (1);
}
if (params) {
va_list ap;
va_start (ap, sql);
for (pname = va_arg (ap, const gchar *); pname; pname = va_arg (ap, const gchar *)) {
const gchar *value;
GdaHolder *holder;
holder = gda_set_get_holder (params, pname);
value = va_arg (ap, const gchar *);
if (holder)
g_assert (gda_holder_set_value_str (holder, NULL, value, NULL));
g_print ("\t%s => %s\n", pname, value);
va_end (ap);
}
}
id = gda_connection_async_statement_execute (cnc, stmt, params, GDA_STATEMENT_MODEL_RANDOM_ACCESS, NULL, FALSE,
&error);
if (params)
g_object_unref (params);
g_object_unref (stmt);
if (id == 0) {
g_print ("Can't execute ASYNC: %s\n", error && error->message ? error->message : "No detail");
exit (1);
}
g_print ("Assigned task id: %u\n", id);
return id;
}
bool SybConnection::connect(const char *host, const char *user,
const char *password, const char *db_name, unsigned int port) {
bool retcode;
char addr[50];
char cmd[128];
if (strlen(host) > 30) {
return false;
}
sprintf(addr, "%s %u", host, port);
if (sContext_ == NULL) {
if (init_() != CS_SUCCEED) {
return false;
}
}
if (connect_("ewp_sybase_drv", NULL, user, password, db_name)!=CS_SUCCEED) {
return false;
}
if (stmt_) {
terminate_statement(stmt_);
stmt_ = NULL;
}
stmt_ = create_statement();
if (db_name != NULL) {
if (strlen(db_name) > 120) {
return false;
}
sprintf(cmd, "use %s", db_name);
retcode = stmt_->execute_cmd(cmd);
if (!retcode) {
return false;
}
}
limit_row_count_ = 0;
return true;
}
template<typename T> T execute_scalar(const std::string &sql) const {
result results(create_statement(sql));
return (*results.begin())[0].as<T>();
}
ref_ptr<statement> connection::get_statement(std::string const &q)
{
ref_ptr<statement> st = create_statement(q);
return st;
}
Statement *abc_create_continue_statement(void) {
return create_statement(CONTINUE_STATEMENT);
}
Statement *abc_create_break_statement(void) {
return create_statement(BREAK_STATEMENT);
}
if (conn_ == NULL) {
RETURN_ERROR(res, CONN_NULL_ERROR)
}
decode_tuple_header();
if (!decode_string(name)) {
RETURN_ERROR(res, BAD_ARG_ERROR)
}
if (!decode_string(sql)) {
free_string(name);
RETURN_ERROR(res, BAD_ARG_ERROR)
}
conn = (SybConnection*)conn_;
stmt = conn->create_statement(sql);
if (!stmt->prepare_init(name)) {
free(name);
free(sql);
RETURN_ERROR(res, "prepare init failed")
}
if (stmt_map_->add((string)name, (void*)stmt)) {
EiEncoder::encode_ok_msg(name, res);
} else {
stmt->prepare_release();
conn->terminate_statement(stmt);
delete stmt;
EiEncoder::encode_error_msg("already registered prepare name", res);
}
