/* [Re]connects to database */
static GSM_Error SMSDPgSQL_Connect(GSM_SMSDConfig * Config)
{
unsigned char buf[400];
PGresult *Res;
unsigned int port = 5432;
char *pport;
pport = strstr(Config->host, ":");
if (pport) {
*pport++ = '\0';
port = atoi(pport);
}
sprintf(buf, "host = '%s' user = '******' password = '******' dbname = '%s' port = %d", Config->host, Config->user, Config->password, Config->database, port);
SMSDPgSQL_Free(Config);
Config->conn.pg = PQconnectdb(buf);
if (PQstatus(Config->conn.pg) != CONNECTION_OK) {
SMSD_Log(DEBUG_ERROR, Config, "Error connecting to database: %s", PQerrorMessage(Config->conn.pg));
PQfinish(Config->conn.pg);
return ERR_DB_CONNECT;
}
Res = PQexec(Config->conn.pg, "SET NAMES UTF8");
PQclear(Res);
SMSD_Log(DEBUG_INFO, Config, "Connected to database: %s on %s. Server version: %d Protocol: %d",
PQdb(Config->conn.pg), PQhost(Config->conn.pg), PQserverVersion(Config->conn.pg), PQprotocolVersion(Config->conn.pg));
return ERR_NONE;
}
static int c_psql_check_connection (c_psql_database_t *db)
{
/* "ping" */
PQclear (PQexec (db->conn, "SELECT 42;"));
if (CONNECTION_OK != PQstatus (db->conn)) {
PQreset (db->conn);
/* trigger c_release() */
if (0 == db->conn_complaint.interval)
db->conn_complaint.interval = 1;
if (CONNECTION_OK != PQstatus (db->conn)) {
c_complain (LOG_ERR, &db->conn_complaint,
"Failed to connect to database %s: %s",
db->database, PQerrorMessage (db->conn));
return -1;
}
db->proto_version = PQprotocolVersion (db->conn);
if (3 > db->proto_version)
log_warn ("Protocol version %d does not support parameters.",
db->proto_version);
}
db->server_version = PQserverVersion (db->conn);
c_release (LOG_INFO, &db->conn_complaint,
"Successfully reconnected to database %s", PQdb (db->conn));
return 0;
} /* c_psql_check_connection */
static int c_psql_connect (c_psql_database_t *db)
{
char conninfo[4096];
char *buf = conninfo;
int buf_len = sizeof (conninfo);
int status;
if (! db)
return -1;
status = ssnprintf (buf, buf_len, "dbname = '%s'", db->database);
if (0 < status) {
buf += status;
buf_len -= status;
}
C_PSQL_PAR_APPEND (buf, buf_len, "host", db->host);
C_PSQL_PAR_APPEND (buf, buf_len, "port", db->port);
C_PSQL_PAR_APPEND (buf, buf_len, "user", db->user);
C_PSQL_PAR_APPEND (buf, buf_len, "password", db->password);
C_PSQL_PAR_APPEND (buf, buf_len, "sslmode", db->sslmode);
C_PSQL_PAR_APPEND (buf, buf_len, "krbsrvname", db->krbsrvname);
C_PSQL_PAR_APPEND (buf, buf_len, "service", db->service);
db->conn = PQconnectdb (conninfo);
db->proto_version = PQprotocolVersion (db->conn);
return 0;
} /* c_psql_connect */
static int c_psql_check_connection (c_psql_database_t *db)
{
_Bool init = 0;
if (! db->conn) {
init = 1;
/* trigger c_release() */
if (0 == db->conn_complaint.interval)
db->conn_complaint.interval = 1;
c_psql_connect (db);
}
/* "ping" */
PQclear (PQexec (db->conn, "SELECT 42;"));
if (CONNECTION_OK != PQstatus (db->conn)) {
PQreset (db->conn);
/* trigger c_release() */
if (0 == db->conn_complaint.interval)
db->conn_complaint.interval = 1;
if (CONNECTION_OK != PQstatus (db->conn)) {
c_complain (LOG_ERR, &db->conn_complaint,
"Failed to connect to database %s (%s): %s",
db->database, db->instance,
PQerrorMessage (db->conn));
return -1;
}
db->proto_version = PQprotocolVersion (db->conn);
}
db->server_version = PQserverVersion (db->conn);
if (c_would_release (&db->conn_complaint)) {
char *server_host;
int server_version;
server_host = PQhost (db->conn);
server_version = PQserverVersion (db->conn);
c_do_release (LOG_INFO, &db->conn_complaint,
"Successfully %sconnected to database %s (user %s) "
"at server %s%s%s (server version: %d.%d.%d, "
"protocol version: %d, pid: %d)", init ? "" : "re",
PQdb (db->conn), PQuser (db->conn),
C_PSQL_SOCKET3 (server_host, PQport (db->conn)),
C_PSQL_SERVER_VERSION3 (server_version),
db->proto_version, PQbackendPID (db->conn));
if (3 > db->proto_version)
log_warn ("Protocol version %d does not support parameters.",
db->proto_version);
}
return 0;
} /* c_psql_check_connection */
int
conn_get_protocol_version(PGconn *pgconn)
{
int ret;
ret = PQprotocolVersion(pgconn);
Dprintf("conn_connect: using protocol %d", ret);
return ret;
}
/*************************************************************************
*
* Function: sql_create_socket
*
* Purpose: Establish connection to the db
*
*************************************************************************/
static int sql_init_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
char *dbstring;
rlm_sql_postgres_conn_t *conn;
#ifdef HAVE_OPENSSL_CRYPTO_H
static bool ssl_init = false;
if (!ssl_init) {
PQinitOpenSSL(0, 0);
ssl_init = true;
}
#endif
MEM(conn = handle->conn = talloc_zero(handle, rlm_sql_postgres_conn_t));
talloc_set_destructor(conn, _sql_socket_destructor);
dbstring = strchr(config->sql_db, '=') ?
talloc_strdup(conn, config->sql_db) :
talloc_asprintf(conn, "dbname='%s'", config->sql_db);
if (config->sql_server[0] != '\0') {
dbstring = talloc_asprintf_append(dbstring, " host='%s'", config->sql_server);
}
if (config->sql_port[0] != '\0') {
dbstring = talloc_asprintf_append(dbstring, " port=%s", config->sql_port);
}
if (config->sql_login[0] != '\0') {
dbstring = talloc_asprintf_append(dbstring, " user='******'", config->sql_login);
}
if (config->sql_password[0] != '\0') {
dbstring = talloc_asprintf_append(dbstring, " password='******'", config->sql_password);
}
conn->dbstring = dbstring;
conn->db = PQconnectdb(dbstring);
DEBUG2("rlm_sql_postgresql: Connecting using parameters: %s", dbstring);
if (!conn->db || (PQstatus(conn->db) != CONNECTION_OK)) {
ERROR("rlm_sql_postgresql: Connection failed: %s", PQerrorMessage(conn->db));
return -1;
}
DEBUG2("Connected to database '%s' on '%s' server version %i, protocol version %i, backend PID %i ",
PQdb(conn->db), PQhost(conn->db), PQserverVersion(conn->db), PQprotocolVersion(conn->db),
PQbackendPID(conn->db));
return 0;
}
void
pqt_getfmtinfo(const PGconn *conn, PGtypeFormatInfo *info)
{
const char *value;
memset(info, 0, sizeof(PGtypeFormatInfo));
if ((value = PQparameterStatus(conn, "DateStyle")))
pqt_strcpy(info->datestyle, sizeof(info->datestyle), value);
if ((value = PQparameterStatus(conn, "integer_datetimes")))
info->integer_datetimes = strcmp(value, "on")==0 ? TRUE : FALSE;
info->sversion = PQserverVersion(conn);
info->pversion = PQprotocolVersion(conn);
}
static int pdo_pgsql_get_attribute(pdo_dbh_t *dbh, zend_long attr, zval *return_value)
{
pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;
switch (attr) {
case PDO_ATTR_EMULATE_PREPARES:
ZVAL_BOOL(return_value, H->emulate_prepares);
break;
case PDO_PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT:
php_error_docref(NULL TSRMLS_CC, E_DEPRECATED, "PDO::PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT is deprecated, use PDO::ATTR_EMULATE_PREPARES instead");
ZVAL_BOOL(return_value, H->disable_native_prepares);
break;
case PDO_PGSQL_ATTR_DISABLE_PREPARES:
ZVAL_BOOL(return_value, H->disable_prepares);
break;
case PDO_ATTR_CLIENT_VERSION:
ZVAL_STRING(return_value, PG_VERSION);
break;
case PDO_ATTR_SERVER_VERSION:
if (PQprotocolVersion(H->server) >= 3) { /* PostgreSQL 7.4 or later */
ZVAL_STRING(return_value, (char*)PQparameterStatus(H->server, "server_version"));
} else /* emulate above via a query */
{
PGresult *res = PQexec(H->server, "SELECT VERSION()");
if (res && PQresultStatus(res) == PGRES_TUPLES_OK) {
ZVAL_STRING(return_value, (char *)PQgetvalue(res, 0, 0));
}
if (res) {
PQclear(res);
}
}
break;
case PDO_ATTR_CONNECTION_STATUS:
switch (PQstatus(H->server)) {
case CONNECTION_STARTED:
ZVAL_STRINGL(return_value, "Waiting for connection to be made.", sizeof("Waiting for connection to be made.")-1);
break;
case CONNECTION_MADE:
case CONNECTION_OK:
ZVAL_STRINGL(return_value, "Connection OK; waiting to send.", sizeof("Connection OK; waiting to send.")-1);
break;
case CONNECTION_AWAITING_RESPONSE:
ZVAL_STRINGL(return_value, "Waiting for a response from the server.", sizeof("Waiting for a response from the server.")-1);
break;
case CONNECTION_AUTH_OK:
ZVAL_STRINGL(return_value, "Received authentication; waiting for backend start-up to finish.", sizeof("Received authentication; waiting for backend start-up to finish.")-1);
break;
#ifdef CONNECTION_SSL_STARTUP
case CONNECTION_SSL_STARTUP:
ZVAL_STRINGL(return_value, "Negotiating SSL encryption.", sizeof("Negotiating SSL encryption.")-1);
break;
#endif
case CONNECTION_SETENV:
ZVAL_STRINGL(return_value, "Negotiating environment-driven parameter settings.", sizeof("Negotiating environment-driven parameter settings.")-1);
break;
case CONNECTION_BAD:
default:
ZVAL_STRINGL(return_value, "Bad connection.", sizeof("Bad connection.")-1);
break;
}
break;
case PDO_ATTR_SERVER_INFO: {
int spid = PQbackendPID(H->server);
zend_string *str_info =
strpprintf(0,
"PID: %d; Client Encoding: %s; Is Superuser: %s; Session Authorization: %s; Date Style: %s",
spid,
(char*)PQparameterStatus(H->server, "client_encoding"),
(char*)PQparameterStatus(H->server, "is_superuser"),
(char*)PQparameterStatus(H->server, "session_authorization"),
(char*)PQparameterStatus(H->server, "DateStyle"));
ZVAL_STR(return_value, str_info);
}
break;
default:
return 0;
}
return 1;
}
static int pgsql_handle_preparer(pdo_dbh_t *dbh, const char *sql, zend_long sql_len, pdo_stmt_t *stmt, zval *driver_options)
{
pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;
pdo_pgsql_stmt *S = ecalloc(1, sizeof(pdo_pgsql_stmt));
int scrollable;
int ret;
char *nsql = NULL;
int nsql_len = 0;
int emulate = 0;
int execute_only = 0;
S->H = H;
stmt->driver_data = S;
stmt->methods = &pgsql_stmt_methods;
scrollable = pdo_attr_lval(driver_options, PDO_ATTR_CURSOR,
PDO_CURSOR_FWDONLY) == PDO_CURSOR_SCROLL;
if (scrollable) {
if (S->cursor_name) {
efree(S->cursor_name);
}
spprintf(&S->cursor_name, 0, "pdo_crsr_%08x", ++H->stmt_counter);
emulate = 1;
} else if (driver_options) {
if (pdo_attr_lval(driver_options, PDO_PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT, H->disable_native_prepares) == 1) {
php_error_docref(NULL, E_DEPRECATED, "PDO::PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT is deprecated, use PDO::ATTR_EMULATE_PREPARES instead");
emulate = 1;
}
if (pdo_attr_lval(driver_options, PDO_ATTR_EMULATE_PREPARES, H->emulate_prepares) == 1) {
emulate = 1;
}
if (pdo_attr_lval(driver_options, PDO_PGSQL_ATTR_DISABLE_PREPARES, H->disable_prepares) == 1) {
execute_only = 1;
}
} else {
emulate = H->disable_native_prepares || H->emulate_prepares;
execute_only = H->disable_prepares;
}
if (!emulate && PQprotocolVersion(H->server) > 2) {
stmt->supports_placeholders = PDO_PLACEHOLDER_NAMED;
stmt->named_rewrite_template = "$%d";
ret = pdo_parse_params(stmt, (char*)sql, sql_len, &nsql, &nsql_len);
if (ret == 1) {
/* query was re-written */
sql = nsql;
} else if (ret == -1) {
/* couldn't grok it */
strcpy(dbh->error_code, stmt->error_code);
return 0;
}
if (!execute_only) {
/* prepared query: set the query name and defer the
actual prepare until the first execute call */
spprintf(&S->stmt_name, 0, "pdo_stmt_%08x", ++H->stmt_counter);
}
if (nsql) {
S->query = nsql;
} else {
S->query = estrdup(sql);
}
return 1;
}
stmt->supports_placeholders = PDO_PLACEHOLDER_NONE;
return 1;
}
int pg_con_connect(db_con_t *con)
{
struct pg_con *pcon;
struct pg_uri *puri;
char *port_str;
int ret, i = 0;
const char *keywords[10], *values[10];
char to[16];
pcon = DB_GET_PAYLOAD(con);
puri = DB_GET_PAYLOAD(con->uri);
/* Do not reconnect already connected connections */
if(pcon->flags & PG_CONNECTED)
return 0;
DBG("postgres: Connecting to %.*s:%.*s\n", con->uri->scheme.len,
ZSW(con->uri->scheme.s), con->uri->body.len, ZSW(con->uri->body.s));
if(puri->port > 0) {
port_str = int2str(puri->port, 0);
keywords[i] = "port";
values[i++] = port_str;
} else {
port_str = NULL;
}
if(pcon->con) {
PQfinish(pcon->con);
pcon->con = NULL;
}
keywords[i] = "host";
values[i++] = puri->host;
keywords[i] = "dbname";
values[i++] = puri->database;
keywords[i] = "user";
values[i++] = puri->username;
keywords[i] = "password";
values[i++] = puri->password;
if(pg_timeout > 0) {
snprintf(to, sizeof(to) - 1, "%d", pg_timeout + 3);
keywords[i] = "connect_timeout";
values[i++] = to;
}
keywords[i] = values[i] = NULL;
pcon->con = PQconnectdbParams(keywords, values, 1);
if(pcon->con == NULL) {
ERR("postgres: PQconnectdbParams ran out of memory\n");
goto error;
}
if(PQstatus(pcon->con) != CONNECTION_OK) {
ERR("postgres: %s\n", PQerrorMessage(pcon->con));
goto error;
}
/* Override default notice processor */
PQsetNoticeProcessor(pcon->con, notice_processor, 0);
#ifdef HAVE_PGSERVERVERSION
DBG("postgres: Connected. Protocol version=%d, Server version=%d\n",
PQprotocolVersion(pcon->con), PQserverVersion(pcon->con));
#else
DBG("postgres: Connected. Protocol version=%d, Server version=%d\n",
PQprotocolVersion(pcon->con), 0);
#endif
#if defined(SO_KEEPALIVE) && defined(TCP_KEEPIDLE)
if(pg_keepalive) {
i = 1;
if(setsockopt(
PQsocket(pcon->con), SOL_SOCKET, SO_KEEPALIVE, &i, sizeof(i))
< 0) {
LM_WARN("failed to set socket option keepalive\n");
}
if(setsockopt(PQsocket(pcon->con), IPPROTO_TCP, TCP_KEEPIDLE,
&pg_keepalive, sizeof(pg_keepalive))
< 0) {
LM_WARN("failed to set socket option keepidle\n");
}
}
#endif
ret = timestamp_format(pcon->con);
if(ret == 1 || ret == -1) {
/* Assume INT8 representation if detection fails */
pcon->flags |= PG_INT8_TIMESTAMP;
} else {
pcon->flags &= ~PG_INT8_TIMESTAMP;
}
if(get_oids(con) < 0)
goto error;
pcon->flags |= PG_CONNECTED;
return 0;
error:
if(pcon->con)
PQfinish(pcon->con);
pcon->con = NULL;
return -1;
}
int getPromoImages( struct db_context_t *dbc,
struct promotional_processing_t *data)
{
int i = 0 ;
char sql_cmd[512];
PGresult *res;
int j;
/* Create SQL Command */
memset( sql_cmd , 0x00 , sizeof( sql_cmd ) ) ;
sprintf(sql_cmd,STMT_getPromoImages,
data->i_id,
data->i_id,
data->i_id,
data->i_id,
data->i_id);
/* Execute SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
if (PQntuples(res) == 0)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
LOG_ERROR_MESSAGE("Could not obtain promo images\n");
PQclear(res);
return ERROR;
}
/* Get data */
for (i = 0;i < 5 && i < PQntuples(res);i++)
{
j = 0;
data->i_related[i] = atoll(PQgetvalue(res, i, j++));
data->i_thumbnail[i] = atoll(PQgetvalue(res, i, j++));
}
PQclear(res);
return OK;
}
int updateSC(struct db_context_t *dbc,
struct buy_request_t *data)
{
long long i_id[SHOPPING_CART_ITEMS_MAX];
int scl_qty = 0 ;
int sc_qty = 0;
int ix =0 , iy = 0 ; /* Loop Counter */
double i_cost[SHOPPING_CART_ITEMS_MAX];
double sub_total = 0.0;
char sql_cmd[512];
PGresult *res;
int j;
for ( ix =0 ; ix < SHOPPING_CART_ITEMS_MAX ; ix++ )
{
i_id[ix] = 0;
i_cost[ix] = 0;
}
ix = 0;
/* */
/* STEP 1 SELECT CART Info */
/* */
/* Create SQL Command */
memset(sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd,STMT_updateSC_sel, data->sc_id);
/* Execute SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
if (PQntuples(res) == 0)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
LOG_ERROR_MESSAGE("Could not obtain shopping_cart info\n");
PQclear(res);
return ERROR;
}
/* Get data */
for (ix=0;ix<SHOPPING_CART_ITEMS_MAX && ix < PQntuples(res);ix++)
{
j = 0;
i_id[ix] = atoll(PQgetvalue(res, ix, j++));
scl_qty = atoi(PQgetvalue(res, ix, j++));
i_cost[ix] = strtod(PQgetvalue(res, ix, j++), NULL);
sub_total += i_cost[ix]*scl_qty;
sc_qty += scl_qty;
}
PQclear(res);
/* UPDATE Shopping Cart Line */
for (iy=0;iy<ix;iy++)
{
/* Create SQL Command */
memset(sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd,STMT_updateSC_updscl,i_cost[iy],i_id[iy],data->sc_id);
/* Execute SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
PQclear(res);
}
/* */
/* STEP 2 Update Shopping Cart */
/* */
data->sc_sub_total = sub_total * (1-data->c_discount);
data->sc_tax = data->sc_sub_total * 0.0825;
data->sc_ship_cost = 3.00 +(1.00*sc_qty);
data->sc_total = data->sc_sub_total + data->sc_ship_cost + data->sc_tax;
/* Create SQL Command */
memset(sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd,
STMT_updateSC_updsc,
data->sc_sub_total,
data->sc_tax,
data->sc_ship_cost,
data->sc_total,
data->sc_id);
/* Execute SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
PQclear(res);
return OK;
}
int getCustInfo(struct db_context_t *dbc,
struct buy_request_t *data)
{
char sql_cmd[512];
PGresult *res;
int j;
/* Create SQL Command */
memset(sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd,STMT_getCustInfo, data->c_uname);
/* Execute get Customer Infomation. */
/* Execute SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
if (PQntuples(res) == 0)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
LOG_ERROR_MESSAGE("Could not fetch customer info for c_uname: %s\n", data->c_uname);
PQclear(res);
return ERROR;
}
/* Get data */
j = 0;
strcpy(data->c_passwd, PQgetvalue(res, 0, j++));
strcpy(data->c_fname, PQgetvalue(res, 0, j++));
strcpy(data->c_lname, PQgetvalue(res, 0, j++));
strcpy(data->c_phone, PQgetvalue(res, 0, j++));
strcpy(data->c_email, PQgetvalue(res, 0, j++));
strcpy(data->c_data, PQgetvalue(res, 0, j++));
strcpy(data->c_birthdate, PQgetvalue(res, 0, j++));
data->c_discount = strtod(PQgetvalue(res, 0, j++), NULL);
strcpy(data->address.addr_street1, PQgetvalue(res, 0, j++));
strcpy(data->address.addr_street2, PQgetvalue(res, 0, j++));
strcpy(data->address.addr_city, PQgetvalue(res, 0, j++));
strcpy(data->address.addr_state, PQgetvalue(res, 0, j++));
strcpy(data->address.addr_zip, PQgetvalue(res, 0, j++));
strcpy(data->address.co_name, PQgetvalue(res, 0, j++));
PQclear(res);
/* Create SQL Command */
memset(sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd,STMT_updateCustInfo, data->c_id);
/* Execute SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
PQclear(res);
return OK;
}
bool
handleCopyIn(PGconn *conn, FILE *copystream, bool isbinary, PGresult **res)
{
bool OK;
const char *prompt;
char buf[COPYBUFSIZ];
/*
* Establish longjmp destination for exiting from wait-for-input. (This is
* only effective while sigint_interrupt_enabled is TRUE.)
*/
if (sigsetjmp(sigint_interrupt_jmp, 1) != 0)
{
/* got here with longjmp */
/* Terminate data transfer */
PQputCopyEnd(conn,
(PQprotocolVersion(conn) < 3) ? NULL :
_("canceled by user"));
OK = false;
goto copyin_cleanup;
}
/* Prompt if interactive input */
if (isatty(fileno(copystream)))
{
if (!pset.quiet)
puts(_("Enter data to be copied followed by a newline.\n"
"End with a backslash and a period on a line by itself."));
prompt = get_prompt(PROMPT_COPY);
}
else
prompt = NULL;
OK = true;
if (isbinary)
{
/* interactive input probably silly, but give one prompt anyway */
if (prompt)
{
fputs(prompt, stdout);
fflush(stdout);
}
for (;;)
{
int buflen;
/* enable longjmp while waiting for input */
sigint_interrupt_enabled = true;
buflen = fread(buf, 1, COPYBUFSIZ, copystream);
sigint_interrupt_enabled = false;
if (buflen <= 0)
break;
if (PQputCopyData(conn, buf, buflen) <= 0)
{
OK = false;
break;
}
}
}
else
{
bool copydone = false;
while (!copydone)
{ /* for each input line ... */
bool firstload;
bool linedone;
if (prompt)
{
fputs(prompt, stdout);
fflush(stdout);
}
firstload = true;
linedone = false;
while (!linedone)
{ /* for each bufferload in line ... */
int linelen;
char *fgresult;
/* enable longjmp while waiting for input */
sigint_interrupt_enabled = true;
fgresult = fgets(buf, sizeof(buf), copystream);
sigint_interrupt_enabled = false;
if (!fgresult)
{
copydone = true;
break;
}
linelen = strlen(buf);
/* current line is done? */
if (linelen > 0 && buf[linelen - 1] == '\n')
linedone = true;
/* check for EOF marker, but not on a partial line */
if (firstload)
{
/*
* This code erroneously assumes '\.' on a line alone
* inside a quoted CSV string terminates the \copy.
* http://www.postgresql.org/message-id/E1TdNVQ-0001ju-GO@w
* rigleys.postgresql.org
*/
if (strcmp(buf, "\\.\n") == 0 ||
strcmp(buf, "\\.\r\n") == 0)
{
copydone = true;
break;
}
firstload = false;
}
if (PQputCopyData(conn, buf, linelen) <= 0)
{
OK = false;
copydone = true;
break;
}
}
if (copystream == pset.cur_cmd_source)
pset.lineno++;
}
}
/* Check for read error */
if (ferror(copystream))
OK = false;
/*
* Terminate data transfer. We can't send an error message if we're using
* protocol version 2.
*/
if (PQputCopyEnd(conn,
(OK || PQprotocolVersion(conn) < 3) ? NULL :
_("aborted because of read failure")) <= 0)
OK = false;
copyin_cleanup:
/*
* Check command status and return to normal libpq state.
*
* We do not want to return with the status still PGRES_COPY_IN: our
* caller would be unable to distinguish that situation from reaching the
* next COPY in a command string that happened to contain two consecutive
* COPY FROM STDIN commands. We keep trying PQputCopyEnd() in the hope
* it'll work eventually. (What's actually likely to happen is that in
* attempting to flush the data, libpq will eventually realize that the
* connection is lost. But that's fine; it will get us out of COPY_IN
* state, which is what we need.)
*/
while (*res = PQgetResult(conn), PQresultStatus(*res) == PGRES_COPY_IN)
{
OK = false;
PQclear(*res);
/* We can't send an error message if we're using protocol version 2 */
PQputCopyEnd(conn,
(PQprotocolVersion(conn) < 3) ? NULL :
_("trying to exit copy mode"));
}
if (PQresultStatus(*res) != PGRES_COMMAND_OK)
{
psql_error("%s", PQerrorMessage(conn));
OK = false;
}
return OK;
}
int pg_con_connect(db_con_t* con)
{
struct pg_con* pcon;
struct pg_uri* puri;
char* port_str;
int ret;
pcon = DB_GET_PAYLOAD(con);
puri = DB_GET_PAYLOAD(con->uri);
/* Do not reconnect already connected connections */
if (pcon->flags & PG_CONNECTED) return 0;
DBG("postgres: Connecting to %.*s:%.*s\n",
con->uri->scheme.len, ZSW(con->uri->scheme.s),
con->uri->body.len, ZSW(con->uri->body.s));
if (puri->port > 0) {
port_str = int2str(puri->port, 0);
} else {
port_str = NULL;
}
if (pcon->con) {
PQfinish(pcon->con);
pcon->con = NULL;
}
pcon->con = PQsetdbLogin(puri->host, port_str,
NULL, NULL, puri->database,
puri->username, puri->password);
if (pcon->con == NULL) {
ERR("postgres: PQsetdbLogin ran out of memory\n");
goto error;
}
if (PQstatus(pcon->con) != CONNECTION_OK) {
ERR("postgres: %s\n", PQerrorMessage(pcon->con));
goto error;
}
/* Override default notice processor */
PQsetNoticeProcessor(pcon->con, notice_processor, 0);
DBG("postgres: Connected. Protocol version=%d, Server version=%d\n",
PQprotocolVersion(pcon->con),
#ifdef HAVE_PGSERVERVERSION
PQserverVersion(pcon->con)
#else
0
#endif
);
ret = timestamp_format(pcon->con);
if (ret == 1 || ret == -1) {
/* Assume INT8 representation if detection fails */
pcon->flags |= PG_INT8_TIMESTAMP;
} else {
pcon->flags &= ~PG_INT8_TIMESTAMP;
}
if (get_oids(con) < 0) goto error;
pcon->flags |= PG_CONNECTED;
return 0;
error:
if (pcon->con) PQfinish(pcon->con);
pcon->con = NULL;
return -1;
}
int InsertCust(struct db_context_t *dbc,
struct buy_request_t *data)
{
short co_id = 0 ; /* temporarily country ID */
int co_addr_id=0;
char c_uname[21];
char sql_cmd[2048];
int i, j, strmax;
char c_uname_small[21];
bzero(c_uname, sizeof(c_uname));
bzero(c_uname_small, sizeof(c_uname_small));
memset( sql_cmd , 0x00 , sizeof( sql_cmd ) ) ;
PGresult *res;
/* */
/* STEP 1 Get Country ID */
/* */
/* Create SQL Command */
sprintf(sql_cmd,STMT_InsertCust_getCountry, data->address.co_name);
/* Execute SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
if (PQntuples(res) == 0)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
LOG_ERROR_MESSAGE("Could not obtain country id\n");
PQclear(res);
return ERROR;
}
/* Get data */
j = 0;
co_id = atoi(PQgetvalue(res, 0, j++));
PQclear(res);
/* pgxc-modif - get the new customer id first */
/* Create SQL Command */
// get new c_id
memset( sql_cmd , 0x00 , sizeof( sql_cmd ) ) ;
sprintf(sql_cmd,STMT_InsertCust_selInsVal);
/* Execute SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
if (PQntuples(res) == 0)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
LOG_ERROR_MESSAGE("Could not obtain next customer id\n");
PQclear(res);
return ERROR;
}
/* Get data */
j = 0;
data->c_id = atoll(PQgetvalue(res, 0, j++));
PQclear(res);
/* */
if (DigSyl(++(data->c_id),0,c_uname) == W_ERROR)
{
return W_ERROR; // but, always OK.
}
/* pgxc-modif
* we may want to always skip this, as it will always fail...
*/
/* STEP 2 Get Country Address */
/* */
/* create SQL Command */
memset(sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd,STMT_InsertCust_getAddr,
co_id,
data->address.addr_zip,
data->address.addr_state,
data->address.addr_city,
data->address.addr_street1,
data->address.addr_street2,
data->c_id); /* pgxc modification */
/* Execute SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
/* Get data */
j = 0;
if (PQntuples(res) != 0)
{
co_addr_id = atoi(PQgetvalue(res, 0, j++));
}
if( PQntuples(res) == 0 )
{
PQclear(res);
/* Insert Address */
/* Create SQL Command */
//Get addr_id from sequence
memset( sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd,STMT_InsertCust_insAddr_selInsVal);
/* Execute SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
if (PQntuples(res) == 0)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
LOG_ERROR_MESSAGE("Could not obtain next address id");
PQclear(res);
return ERROR;
}
/* Get data */
j = 0;
co_addr_id = atoi(PQgetvalue(res, 0, j++));
PQclear(res);
/* Create SQL Command */
memset( sql_cmd , 0x00 , sizeof( sql_cmd ) ) ;
sprintf(sql_cmd,STMT_InsertCust_insAddr,
co_addr_id,
data->address.addr_street1,
data->address.addr_street2,
data->address.addr_city,
data->address.addr_state,
data->address.addr_zip,
co_id,
data->c_id);
/* use value obtained earlier for c_id. */
/* we cheat a little bit but the c_id is not yet defined, this part is updated when the real c_id is known */
/*data->c_id = 0 here);*/ /* pgxc additional */
/* Execute SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
PQclear(res);
}
else
{
PQclear(res);
}
/* change big char to small char. */
strmax=strlen(c_uname);
for (i = 0; i < strmax; i++)
{
c_uname_small[i] = (char) tolower(c_uname[i]);
}
/* Create SQL Command */
// insert data to customer tables
memset( sql_cmd , 0x00 , sizeof( sql_cmd ) ) ;
sprintf(sql_cmd,STMT_InsertCust_insCust,
data->c_id ,
c_uname,
c_uname_small,
data->c_fname,
data->c_lname,
co_addr_id,
data->c_phone,
data->c_email,
data->c_discount,
data->c_birthdate,
data->c_data);
/* Execute SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
PQclear(res);
return OK;
}
int
main (int argc, char **argv)
{
PGconn *conn;
char *conninfo = NULL;
struct timeval start_timeval;
struct timeval end_timeval;
double elapsed_time;
int status = STATE_UNKNOWN;
int query_status = STATE_UNKNOWN;
/* begin, by setting the parameters for a backend connection if the
* parameters are null, then the system will try to use reasonable
* defaults by looking up environment variables or, failing that,
* using hardwired constants */
pgoptions = NULL; /* special options to start up the backend server */
pgtty = NULL; /* debugging tty for the backend server */
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
/* Parse extra opts if any */
argv=np_extra_opts (&argc, argv, progname);
if (process_arguments (argc, argv) == ERROR)
usage4 (_("Could not parse arguments"));
if (verbose > 2)
printf("Arguments initialized\n");
/* Set signal handling and alarm */
if (signal (SIGALRM, timeout_alarm_handler) == SIG_ERR) {
usage4 (_("Cannot catch SIGALRM"));
}
alarm (timeout_interval);
if (pgparams)
asprintf (&conninfo, "%s ", pgparams);
asprintf (&conninfo, "%sdbname = '%s'", conninfo ? conninfo : "", dbName);
if (pghost)
asprintf (&conninfo, "%s host = '%s'", conninfo, pghost);
if (pgport)
asprintf (&conninfo, "%s port = '%s'", conninfo, pgport);
if (pgoptions)
asprintf (&conninfo, "%s options = '%s'", conninfo, pgoptions);
/* if (pgtty) -- ignored by PQconnectdb */
if (pguser)
asprintf (&conninfo, "%s user = '******'", conninfo, pguser);
if (verbose) /* do not include password (see right below) in output */
printf ("Connecting to PostgreSQL using conninfo: %s%s\n", conninfo,
pgpasswd ? " password = <hidden>" : "");
if (pgpasswd)
asprintf (&conninfo, "%s password = '******'", conninfo, pgpasswd);
/* make a connection to the database */
gettimeofday (&start_timeval, NULL);
conn = PQconnectdb (conninfo);
gettimeofday (&end_timeval, NULL);
while (start_timeval.tv_usec > end_timeval.tv_usec) {
--end_timeval.tv_sec;
end_timeval.tv_usec += 1000000;
}
elapsed_time = (double)(end_timeval.tv_sec - start_timeval.tv_sec)
+ (double)(end_timeval.tv_usec - start_timeval.tv_usec) / 1000000.0;
if (verbose)
printf("Time elapsed: %f\n", elapsed_time);
/* check to see that the backend connection was successfully made */
if (verbose)
printf("Verifying connection\n");
if (PQstatus (conn) == CONNECTION_BAD) {
printf (_("CRITICAL - no connection to '%s' (%s).\n"),
dbName, PQerrorMessage (conn));
PQfinish (conn);
return STATE_CRITICAL;
}
else if (elapsed_time > tcrit) {
status = STATE_CRITICAL;
}
else if (elapsed_time > twarn) {
status = STATE_WARNING;
}
else {
status = STATE_OK;
}
if (verbose) {
char *server_host = PQhost (conn);
int server_version = PQserverVersion (conn);
printf ("Successfully connected to database %s (user %s) "
"at server %s%s%s (server version: %d.%d.%d, "
"protocol version: %d, pid: %d)\n",
PQdb (conn), PQuser (conn),
PSQL_SOCKET3 (server_host, PQport (conn)),
PSQL_SERVER_VERSION3 (server_version),
PQprotocolVersion (conn), PQbackendPID (conn));
}
printf (_(" %s - database %s (%f sec.)|%s\n"),
state_text(status), dbName, elapsed_time,
fperfdata("time", elapsed_time, "s",
!!(twarn > 0.0), twarn, !!(tcrit > 0.0), tcrit, TRUE, 0, FALSE,0));
if (pgquery)
query_status = do_query (conn, pgquery);
if (verbose)
printf("Closing connection\n");
PQfinish (conn);
return (pgquery && query_status > status) ? query_status : status;
}
int commit_transaction(struct db_context_t *dbc)
{
PGresult *res;
res = PQexec(dbc->conn, "COMMIT");
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
PQclear(res);
return OK;
}
static int c_psql_init (void)
{
int i;
if ((NULL == databases) || (0 == databases_num))
return 0;
for (i = 0; i < databases_num; ++i) {
c_psql_database_t *db = databases + i;
char conninfo[4096];
char *buf = conninfo;
int buf_len = sizeof (conninfo);
int status;
char *server_host;
int server_version;
/* this will happen during reinitialization */
if (NULL != db->conn) {
c_psql_check_connection (db);
continue;
}
status = ssnprintf (buf, buf_len, "dbname = '%s'", db->database);
if (0 < status) {
buf += status;
buf_len -= status;
}
C_PSQL_PAR_APPEND (buf, buf_len, "host", db->host);
C_PSQL_PAR_APPEND (buf, buf_len, "port", db->port);
C_PSQL_PAR_APPEND (buf, buf_len, "user", db->user);
C_PSQL_PAR_APPEND (buf, buf_len, "password", db->password);
C_PSQL_PAR_APPEND (buf, buf_len, "sslmode", db->sslmode);
C_PSQL_PAR_APPEND (buf, buf_len, "krbsrvname", db->krbsrvname);
C_PSQL_PAR_APPEND (buf, buf_len, "service", db->service);
db->conn = PQconnectdb (conninfo);
if (0 != c_psql_check_connection (db))
continue;
db->proto_version = PQprotocolVersion (db->conn);
server_host = PQhost (db->conn);
server_version = PQserverVersion (db->conn);
log_info ("Sucessfully connected to database %s (user %s) "
"at server %s%s%s (server version: %d.%d.%d, "
"protocol version: %d, pid: %d)",
PQdb (db->conn), PQuser (db->conn),
C_PSQL_SOCKET3 (server_host, PQport (db->conn)),
C_PSQL_SERVER_VERSION3 (server_version),
db->proto_version, PQbackendPID (db->conn));
if (3 > db->proto_version)
log_warn ("Protocol version %d does not support parameters.",
db->proto_version);
}
plugin_register_read ("postgresql", c_psql_read);
plugin_register_shutdown ("postgresql", c_psql_shutdown);
return 0;
} /* c_psql_init */
bool EpollPostgresql::syncConnectInternal(bool infinityTry)
{
conn=PQconnectdb(strCoPG);
ConnStatusType connStatusType=PQstatus(conn);
if(connStatusType==CONNECTION_BAD)
{
std::string lastErrorMessage=errorMessage();
if(!infinityTry)
{
if(lastErrorMessage.find("pg_hba.conf")!=std::string::npos)
return false;
if(lastErrorMessage.find("authentication failed")!=std::string::npos)
return false;
if(lastErrorMessage.find("role \"")!=std::string::npos)
{
if(lastErrorMessage.find("\" does not exist")!=std::string::npos)
return false;
if(lastErrorMessage.find("\" is not permitted to log in")!=std::string::npos)
return false;
}
}
std::cerr << "pg connexion not OK: " << lastErrorMessage << ", retrying..., infinityTry: " << std::to_string(infinityTry) << std::endl;
unsigned int index=0;
while(index<considerDownAfterNumberOfTry && connStatusType==CONNECTION_BAD)
{
auto start = std::chrono::high_resolution_clock::now();
PQfinish(conn);
conn=PQconnectdb(strCoPG);
connStatusType=PQstatus(conn);
auto end = std::chrono::high_resolution_clock::now();
std::chrono::duration<double, std::milli> elapsed = end-start;
if(elapsed.count()<(uint32_t)tryInterval*1000 && connStatusType==CONNECTION_BAD)
{
std::string newErrorMessage=errorMessage();
if(lastErrorMessage!=newErrorMessage)
{
std::cerr << "pg connexion not OK: " << lastErrorMessage << ", retrying..." << std::endl;
lastErrorMessage=newErrorMessage;
}
const unsigned int ms=(uint32_t)tryInterval*1000-elapsed.count();
std::this_thread::sleep_for(std::chrono::milliseconds(ms));
}
if(!infinityTry)
index++;
if(lastErrorMessage.find("the database system is starting up")!=std::string::npos || lastErrorMessage.find("the database system is shutting down")!=std::string::npos)
index=0;
}
if(connStatusType==CONNECTION_BAD)
return false;
}
#if defined(CATCHCHALLENGER_DB_PREPAREDSTATEMENT)
{
unsigned int index=0;
while(index<preparedStatementUnitList.size())
{
const PreparedStatementStore &preparedStatement=preparedStatementUnitList.at(index);
queryPrepare(preparedStatement.name.c_str(),preparedStatement.query.c_str(),preparedStatement.nParams,false);
index++;
}
}
#endif
if(!setBlocking(1))
{
std::cerr << "pg no blocking error" << std::endl;
return false;
}
int sock = PQsocket(conn);
if (sock < 0)
{
std::cerr << "pg no sock" << std::endl;
return false;
}
/* Use no delay, will not be able to group tcp message because is ordened into a queue
* Then the execution is on by one, and the RTT will slow down this */
{
int state = 1;
if(setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &state, sizeof(state))!=0)
std::cerr << "Unable to apply tcp no delay" << std::endl;
}
epoll_event event;
event.events = EPOLLOUT | EPOLLIN | EPOLLRDHUP | EPOLLERR | EPOLLET;
event.data.ptr = this;
// add the socket to the epoll file descriptors
if(Epoll::epoll.ctl(EPOLL_CTL_ADD,sock,&event) != 0)
{
std::cerr << "epoll_ctl, adding socket error" << std::endl;
return false;
}
PQsetNoticeReceiver(conn,noticeReceiver,NULL);
PQsetNoticeProcessor(conn,noticeProcessor,NULL);
started=true;
std::cout << "Connected to postgresql, Protocol version: " << PQprotocolVersion(conn) << ", Server version:" << PQserverVersion(conn) << std::endl;
return true;
}
int execute_product_detail(struct db_context_t *dbc,
struct product_detail_t *data)
{
char sql_cmd[512];
PGresult *res;
int j;
/* Create SQL Command */
memset(sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd,STMT_PRODUCT_DETAIL, data->i_id);
/* Execute SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
if (PQntuples(res) == 0)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
LOG_ERROR_MESSAGE("Could not obtain produce detail\n");
PQclear(res);
return ERROR;
}
/* Get data */
j = 0;
strcpy(data->i_title, PQgetvalue(res, 0, j++));
strcpy(data->a_fname, PQgetvalue(res, 0, j++));
strcpy(data->a_lname, PQgetvalue(res, 0, j++));
strcpy(data->i_pub_date, PQgetvalue(res, 0, j++));
strcpy(data->i_publisher, PQgetvalue(res, 0, j++));
strcpy(data->i_subject, PQgetvalue(res, 0, j++));
strcpy(data->i_desc, PQgetvalue(res, 0, j++));
data->i_image = atoll(PQgetvalue(res, 0, j++));
data->i_cost = strtod(PQgetvalue(res, 0, j++), NULL);
data->i_srp = strtod(PQgetvalue(res, 0, j++), NULL);
strcpy(data->i_avail, PQgetvalue(res, 0, j++));
strcpy(data->i_isbn, PQgetvalue(res, 0, j++));
data->i_page = atoi(PQgetvalue(res, 0, j++));
strcpy(data->i_backing, PQgetvalue(res, 0, j++));
strcpy(data->i_dimensions, PQgetvalue(res, 0, j++));
PQclear(res);
return OK;
}
int execute_buy_confirm(struct db_context_t *dbc,
struct buy_confirm_t *data)
{
short int ship_day = 0;
char ol_comment[OL_COMMENT_LEN + 1];
char cx_auth_id[CX_AUTH_ID_LEN + 1];
char sql_cmd[2048];
long long c_addr_id = 0;
char c_fname[C_FNAME_LEN+1];
char c_lname[C_LNAME_LEN+1];
short co_id = 0;
long long ship_addr_id = 0;
long long scl_i_id[SHOPPING_CART_ITEMS_MAX];
short scl_qty[SHOPPING_CART_ITEMS_MAX];
double scl_cost[SHOPPING_CART_ITEMS_MAX];
int ol_id = 0;
int st_stock = 0;
int ix,iy; /* Loop Counter */
PGresult *res;
int j;
for ( ix =0 ; ix < SHOPPING_CART_ITEMS_MAX ; ix++ )
{
scl_i_id[ix] = 0;
scl_qty[ix] = 0;
scl_cost[ix] = 0;
}
ix = 0;
bzero(ol_comment,sizeof(ol_comment));
bzero(cx_auth_id,sizeof(cx_auth_id));
bzero(sql_cmd,sizeof(sql_cmd));
bzero(c_fname,sizeof(c_fname));
bzero(c_lname,sizeof(c_lname));
/* Generate random day between 1 to 7 for ship_date. */
ship_day = get_random_int(7) + 1;
/* get authentication id from PGE */
strcpy(cx_auth_id, "012345678912345");
/* generate a_string[20..100] as order_line comment */
get_a_string(ol_comment, 20, 100);
/* SELECT shopping_cart Info */
if( data->sc_id != 0 )
{
// if data->sc_id not Zero, Select data from Shopping_Cart Table
/* Create SQL Command */
sprintf(sql_cmd,STMT_BUYCONF_selSC2,data->sc_id);
/* **MOBILE CODE** SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
if (PQntuples(res) != 0)
{
/* Get data */
j = 0;
data->sc_sub_total = strtod(PQgetvalue(res, 0, j++), NULL);
data->sc_tax = strtod(PQgetvalue(res, 0, j++), NULL);
data->sc_ship_cost = strtod(PQgetvalue(res, 0, j++), NULL);
data->sc_total = strtod(PQgetvalue(res, 0, j++), NULL);
PQclear(res);
}
else
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
LOG_ERROR_MESSAGE("Could not obtain shopping_cart info for sc_id = %d\n", data->sc_id); /* pgxc modif: addition of c_id */
PQclear(res);
return ERROR;
}
}
else
{
// if data-> sc_id is Zero, Get Shopping_Cart iD from Shopping_Cart Table
/* Create SQL Command */
sprintf(sql_cmd,STMT_BUYCONF_selInsVal);
/* **MOBILE CODE** SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
/* Get data */
if (PQntuples(res) != 0)
{
j = 0;
data->sc_id = atoll(PQgetvalue(res, 0, j++));
PQclear(res);
}
else
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
LOG_ERROR_MESSAGE("Could not obtain shopping_cart_id\n"); /* pgxc modif: addition of c_id */
PQclear(res);
return ERROR;
}
//insert data is all Zero
data->sc_sub_total = 0;
data->sc_tax = 0;
data->sc_ship_cost = 0;
data->sc_total = 0;
}
/* SELECT customer Info */
/* Create SQL command */
memset(sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd,STMT_BUYCONF_selCS,data->c_id);
/* **MOBILE CODE** SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
if (PQntuples(res) != 0)
{
/* Get data */
j = 0;
strcpy(c_fname, PQgetvalue(res, 0, j++));
strcpy(c_lname, PQgetvalue(res, 0, j++));
data->c_discount = strtod(PQgetvalue(res, 0, j++), NULL);
c_addr_id = atoll(PQgetvalue(res, 0, j++));
PQclear(res);
}
else
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
LOG_ERROR_MESSAGE("Could not select customer = %d\n", data->c_id); /* pgxc modif: addition of c_id */
PQclear(res);
return ERROR;
}
if (data->shipping.addr_street1[0] != 0x00)
{
/* SELECT ADDRESS */
/* Create SQL command */
memset(sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd, STMT_BUYCONF_selADRCNT,
data->shipping.co_name,
data->shipping.addr_zip,
data->shipping.addr_state,
data->shipping.addr_city,
data->shipping.addr_street1,
data->shipping.addr_street2,
data->c_id); /* pgxc additional */
/* **MOBILE CODE** SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
/* Get data */
j = 0;
if (PQntuples(res) != 0)
{
ship_addr_id = atoll(PQgetvalue(res, 0, j++));
co_id = atoi(PQgetvalue(res, 0, j++));
}
if(PQntuples(res) == 0)
{
PQclear(res);
/* Create SQL command */
memset(sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd,STMT_BUYCONF_getCountry, data->shipping.co_name);
/* **MOBILE CODE** SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
/* Get data */
if (PQntuples(res) != 0)
{
j = 0;
co_id = atoi(PQgetvalue(res, 0, j++));
}
else
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
LOG_ERROR_MESSAGE("Could not obtain country for %s", data->shipping.co_name);
PQclear(res);
return ERROR;
}
PQclear(res);
//select id from sequense
/* Create SQL command */
memset(sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd,STMT_BUYCONF_selADRID);
/* **MOBILE CODE** SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
/* Get data */
if (PQntuples(res) != 0)
{
j = 0;
ship_addr_id = atoll(PQgetvalue(res, 0, j++));
PQclear(res);
}
else
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
LOG_ERROR_MESSAGE("Could not obtain addr_id");
PQclear(res);
return ERROR;
}
/* INSERT ADDRESS */
/* Create SQL command */
memset(sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd,STMT_BUYCONF_insADR,
ship_addr_id,
data->shipping.addr_street1,
data->shipping.addr_street2,
data->shipping.addr_city,
data->shipping.addr_state,
data->shipping.addr_zip,
co_id,
data->c_id);
/* **MOBILE CODE** SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
PQclear(res);
}
else
{
PQclear(res);
}
}
else
{
/* SELECT ADDRESS */
/* Create SQL command */
ship_addr_id = c_addr_id;
memset(sql_cmd, 0x00, sizeof(sql_cmd));
if (data->c_id > 0)
sprintf(sql_cmd,STMT_BUYCONF_selADR,ship_addr_id,data->c_id); /* pgxc modif: addition of c_id */
else
sprintf(sql_cmd,STMT_BUYCONF_selADR_nocust,ship_addr_id); /* pgxc modif */
/* **MOBILE CODE** SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK )
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
/* Get data */
if (PQntuples(res) != 0)
{
j = 0;
co_id = atoi(PQgetvalue(res, 0, j++));
PQclear(res);
}
else
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
LOG_ERROR_MESSAGE("Could not obtain address for addr_id = %d, c_id = %lld\n", ship_addr_id, data->c_id); /* pgxc modif: addition of c_id */
PQclear(res);
return ERROR;
}
}
/* INSERT ORDERS */
/* Create SQL command */
memset(sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd,STMT_BUYCONF_insODR,
data->sc_id,
data->c_id,
data->sc_sub_total,
data->sc_tax,
data->sc_total,
ship_day,
c_addr_id,
ship_addr_id);
/* **MOBILE CODE** SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
PQclear(res);
/* seems to block here in case scl was created with a c_id null if the customer made the shopping cart before being registered */
/* SELECT Shopping Cart Line */
/* Create SQL command */
memset( sql_cmd , 0x00 , sizeof( sql_cmd ) );
sprintf(sql_cmd,STMT_BUYCONF_selSCL,data->sc_id); /*,data->c_id);*/
/* **MOBILE CODE** SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
if (PQntuples(res) != 0)
{
/* Get data */
for (ix=0;ix<SHOPPING_CART_ITEMS_MAX && ix < PQntuples(res);ix++)
{
j = 0;
scl_i_id[ix] = atoll(PQgetvalue(res, ix, j++));
scl_cost[ix] = strtod(PQgetvalue(res, ix, j++), NULL);
scl_qty[ix] = atoi(PQgetvalue(res, ix, j++));
}
PQclear(res);
}
else
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
LOG_ERROR_MESSAGE("Could not select shopping_cart for sc_id = %d\n", data->sc_id); /* pgxc modif: addition of c_id */
PQclear(res);
return ERROR;
}
for (iy=0;iy<ix;iy++)
{
/* INSERT ORDER Line */
/* Create SQL command */
memset(sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd,STMT_BUYCONF_insODRL,
++ol_id,
data->sc_id,
scl_i_id[iy],
scl_qty[iy],
data->c_discount,
ol_comment,
data->c_id); /* pgxc additional */
/* **MOBILE CODE** SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
PQclear(res);
/* SELECT Item */
/* Create SQL command */
memset(sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd,STMT_BUYCONF_selITM, scl_i_id[iy]); /* for pgxc nothing changed here, not necessary as stock is a partition of item just depending on it */
/* **MOBILE CODE** SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
/* Get data */
if (PQntuples(res) != 0)
{
j = 0;
co_id = atoi(PQgetvalue(res, 0, j++));
PQclear(res);
}
else
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
LOG_ERROR_MESSAGE("Could not obtain item = %d\n", scl_i_id[iy]); /* pgxc modif: addition of c_id */
PQclear(res);
return ERROR;
}
if (st_stock - 10 > scl_qty[iy])
{
st_stock -= scl_qty[iy];
}
else
{
st_stock = st_stock - scl_qty[iy] + 21;
}
/* UPDATE Item */
/* Create SQL command */
memset(sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd,STMT_BUYCONF_updITM, st_stock,scl_i_id[iy]); /* pgxc modif: name of stock variable changed to st_stock */
/* **MOBILE CODE** SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
PQclear(res);
}
/* INSERT cc_xacts */
/* Create SQL command */
memset(sql_cmd, 0x00, sizeof(sql_cmd));
sprintf(sql_cmd,STMT_BUYCONF_insXACT,
data->sc_id,
data->cx_type,
data->cx_num,
data->cx_name,
data->cx_expiry,
cx_auth_id,
data->sc_total,
co_id,
data->c_id); /* pgxc additional */
/* **MOBILE CODE** SQL Command */
res = PQexec(dbc->conn, sql_cmd);
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
{
LOG_ERROR_MESSAGE("%s\nPQbackendPID[%d]\nPQstatus[%d]\nPQtransactionStatus[%d]\nPQsocket[%d]\nPQprotocolVersion[%d]\n", PQerrorMessage(dbc->conn), PQbackendPID(dbc->conn), (int)PQstatus(dbc->conn), (int)PQtransactionStatus(dbc->conn), PQsocket(dbc->conn), PQprotocolVersion(dbc->conn));
PQclear(res);
return ERROR;
}
PQclear(res);
if (getSCDetail(dbc, data->scl_data, data->sc_id, data->c_id, &data->sc_size) == W_ERROR)
{
return W_ERROR;
}
return OK;
}
