static int
init(DBPROCESS * dbproc, const char *name)
{
int res = 0;
fprintf(stdout, "Dropping %s.%s..%s\n", SERVER, DATABASE, name);
add_bread_crumb();
sprintf(cmd, "if exists (select 1 from sysobjects where type = 'U' and name = '%s') drop table %s", name, name);
dbcmd(dbproc, cmd);
add_bread_crumb();
dbsqlexec(dbproc);
add_bread_crumb();
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
add_bread_crumb();
fprintf(stdout, "Creating %s.%s..%s\n", SERVER, DATABASE, name);
dbcmd(dbproc, create_table_sql);
if (dbsqlexec(dbproc) == FAIL) {
add_bread_crumb();
res = 1;
}
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
return res;
}
/* verify that the provider class is valid(exist in PROVIDER_CLASS_REF) */
int
verify_provider_class(RATE_USAGE_OVERRIDES_STRUCT *struct_ptr, int *count)
{
int i=0;
int ret_code;
dbcmd(dbproc1, " select count(*) ");
dbcmd(dbproc1, " from PROVIDER_CLASS_REF ");
dbfcmd(dbproc1, " where provider_class = %s", struct_ptr->provider_class);
if (safe_dbselect(dbproc1, "PROVIDER_CLASS_REF",
"verify_provider_class"))
{
return(FAILURE);
}
dbbind(dbproc1,1,INTBIND,0, count);
while (dbnextrow(dbproc1) == REG_ROW)
{
i++;
} /* end of while loop */
if(check_dbresults(dbproc1,ret_code,"PROVIDER_CLASS_REF",
"verify_provider_class"))
{
return(FAILURE);
}
return (SUCCESS);
}
int
delete_col_collector_db()
{
char *db_string;
int i = 0, ret_code;
dbcmd(dbproc1," delete COL_COLLECTOR ");
dbcmd(dbproc1, " where ");
db_string =
(char *)convert_to_db_string(col_collector_selected.collector_id);
dbfcmd(dbproc1, " collector_id = %d",
atoi(db_string));
free(db_string);
if(safe_dbupdate(dbproc1, "COL_COLLECTOR",
"delete_col_collector_db"))
{
return(FAILURE);
}
while ((ret_code = dbnextrow(dbproc1)) == REG_ROW)
{
if (ret_code == FAIL)
{
return(FAILURE);
}
}
if(check_dbresults(dbproc1,ret_code,"COL_COLLECTOR",
"delete_col_collector_db"))
return(FAILURE);
return(SUCCESS);
}
int
verify_type_id_usg(RATE_USAGE_OVERRIDES_STRUCT *struct_ptr, int *count)
{
int i=0;
int ret_code;
dbcmd(dbproc1, " select count(*) ");
dbcmd(dbproc1, " from USAGE_TYPES ");
dbfcmd(dbproc1, " where type_id_usg = %s", struct_ptr->type_id_usg);
if (safe_dbselect(dbproc1, "USAGE_TYPES",
"verify_type_id_usg"))
{
return(FAILURE);
}
dbbind(dbproc1,1,INTBIND,0, count);
while (dbnextrow(dbproc1) == REG_ROW)
{
i++;
} /* end of while loop */
if(check_dbresults(dbproc1,ret_code,"USAGE_TYPES",
"verify_type_id_usg"))
{
return(FAILURE);
}
return (SUCCESS);
}
static RETCODE
init_proc(DBPROCESS * dbproc, const char *name)
{
RETCODE ret = FAIL;
if (name[0] != '#') {
fprintf(stdout, "Dropping procedure %s\n", name);
add_bread_crumb();
sprintf(cmd, "DROP PROCEDURE %s", name);
dbcmd(dbproc, cmd);
add_bread_crumb();
dbsqlexec(dbproc);
add_bread_crumb();
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
add_bread_crumb();
}
fprintf(stdout, "Creating procedure %s\n", name);
sprintf(cmd, procedure_sql, name);
dbcmd(dbproc, cmd);
if ((ret = dbsqlexec(dbproc)) == FAIL) {
add_bread_crumb();
if (name[0] == '#')
fprintf(stdout, "Failed to create procedure %s. Wrong permission or not MSSQL.\n", name);
else
fprintf(stdout, "Failed to create procedure %s. Wrong permission.\n", name);
}
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
return ret;
}
void eft_get_status_codes()
{
int db_code;
char description[81];
RETCODE ret_code;
/* this gets called once and hangs around forever */
description[0] = '\0';
db_code = 0;
eft_num_display_statuses = 0;
if(eft_sel_shell == NULL)
create_eft_sel_shell(eft_shell);
dbcmd(dbeftproc,"select integer_value,display_value from GUI_INDICATOR_VALUES where ");
dbcmd(dbeftproc,"table_name = 'EFT_TRANS' and field_name = 'trans_status'");
dbfcmd(dbeftproc, " and language_code = %d", gGUIlanguage );
br_dbsqlexec(dbeftproc);
if (Sybase_error)
{
dbcancel(dbeftproc);
return;
}
while((ret_code = dbresults(dbeftproc)) != NO_MORE_RESULTS)
{
if(ret_code == FAIL)
{
dbcancel(dbeftproc);
return;
}
dbbind(dbeftproc,1,INTBIND,0,&db_code);
dbbind(dbeftproc,2,NTBSTRINGBIND,0,description);
while (dbnextrow(dbeftproc) != NO_MORE_ROWS)
{
/* Found an entry. */
eft_num_display_statuses++;
eft_display_statuses = (EFT_DB_POPLIST_TYPE *)
realloc (eft_display_statuses,eft_num_display_statuses * sizeof (EFT_DB_POPLIST_TYPE));
eft_display_statuses_list = (XmString *)
realloc (eft_display_statuses_list,eft_num_display_statuses * sizeof (XmString));
eft_display_statuses[eft_num_display_statuses - 1].db_code = db_code;
strcpy (eft_display_statuses[eft_num_display_statuses - 1].description,description);
eft_display_statuses_list[eft_num_display_statuses - 1] = XmStringCreateSimple (description);
}
}
if(Sybase_error)
{
dbcancel(dbeftproc);
return;
}
}
int
get_next_bill_date (char *bill_period, char *billing_frequency,
char *prev_cutoff_date, char *next_bill_date)
{
int ret_code;
/* Nested select statement -- just one way to do this query */
dbfcmd(dbproc1, "select convert(char(8), min(ppdd_date), %d) ", gdatefmt);
dbcmd (dbproc1, "from BILL_CYCLE where ppdd_date in ");
dbcmd (dbproc1, "(select ppdd_date from BILL_CYCLE ");
if ((bill_period == NULL) || (strlen(bill_period) == 0))
dbcmd (dbproc1, "having bill_period = min(bill_period) ");
else
dbfcmd(dbproc1, "having bill_period = '%s' ", bill_period);
if ((billing_frequency == NULL) || (strlen(billing_frequency) == 0))
dbcmd (dbproc1, "and billing_frequency = min(billing_frequency) ");
else
dbfcmd(dbproc1, "and billing_frequency = %s ", billing_frequency);
if ((prev_cutoff_date == NULL) || (strlen(prev_cutoff_date) == 0))
dbcmd (dbproc1, "and cutoff_date > getdate()) ");
else
dbfcmd(dbproc1, "and cutoff_date > '%s') ", prev_cutoff_date);
br_dbsqlexec(dbproc1);
if (Sybase_error)
{
dbcancel(dbproc1);
return(FAILURE);
}
while ((ret_code = dbresults(dbproc1)) != NO_MORE_RESULTS)
{
if (ret_code != SUCCEED)
{
dbcancel(dbproc1);
return(FAILURE);
}
dbbind(dbproc1, 1, NTBSTRINGBIND, 0, next_bill_date);
while (dbnextrow(dbproc1) != NO_MORE_ROWS); /* empty */
}
if (Sybase_error)
{
dbcancel(dbproc1);
return(FAILURE);
}
return (SUCCESS);
} /* end get_next_bill_date */
int
delete_overrides_rc_db()
{
char *db_string;
int i = 0, ret_code;
dbcmd(dbproc1," delete OVERRIDES_RC ");
dbcmd(dbproc1, " where ");
db_string =
(char *)convert_to_db_string(overrides_rc_selected.tax_pkg_inst_id);
dbfcmd(dbproc1, " (tax_pkg_inst_id = %d",
atoi(db_string));
if (atoi(db_string)==0){
dbfcmd(dbproc1, " or tax_pkg_inst_id is NULL) " );
}else{
dbfcmd(dbproc1, ") " );
}
free(db_string);
dbcmd(dbproc1, " and ");
db_string =
(char *)convert_to_db_string(overrides_rc_selected.element_id);
dbfcmd(dbproc1, " element_id = %d",
atoi(db_string));
free(db_string);
dbcmd(dbproc1, " and ");
db_string =
(char *)convert_to_db_string(overrides_rc_selected.geocode);
dbfcmd(dbproc1, " geocode = '%s'",
db_string);
free(db_string);
if(safe_dbupdate(dbproc1, "OVERRIDES_RC",
"delete_overrides_rc_db"))
{
return(FAILURE);
}
while ((ret_code = dbnextrow(dbproc1)) == REG_ROW)
{
if (ret_code == FAIL)
{
return(FAILURE);
}
}
if(check_dbresults(dbproc1,ret_code,"OVERRIDES_RC",
"delete_overrides_rc_db"))
return(FAILURE);
return(SUCCESS);
}
/*
*******************************************
* insert information
*******************************************
*/
int bill_cycle_save_db(BILL_CYCLE_STRUCT *bill_cycle_struct)
{
int i, ret_code;
int status;
char *db_string = NULL;
/*****************************************
Insert into BILL_CYCLE;
*****************************************/
dbcmd(dbproc1," insert into BILL_CYCLE ");
dbcmd(dbproc1, " (bill_period,billing_frequency,ppdd_date,");
dbcmd(dbproc1, " next_ppdd_date,statement_date,cutoff_date,");
dbcmd(dbproc1, " prep_delay)");
dbcmd(dbproc1, " values(");
db_string =
(char *)convert_to_db_string(bill_cycle_struct->bill_period);
dbfcmd(dbproc1, " '%s',",db_string);
free(db_string);
db_string =
(char *)convert_to_db_string(bill_cycle_struct->billing_frequency);
dbfcmd(dbproc1, " %d,",atoi(db_string));
free(db_string);
date_time_to_Arbdate(bill_cycle_struct->ppdd_date,
bill_cycle_struct->ppdd_time, &(bill_cycle_struct->ppdd_dt));
dbfcmd(dbproc1, " %t,", &(bill_cycle_struct->ppdd_dt));
date_time_to_Arbdate(bill_cycle_struct->next_ppdd_date,
bill_cycle_struct->next_ppdd_time, &(bill_cycle_struct->next_ppdd_dt));
dbfcmd(dbproc1, " %t,", &(bill_cycle_struct->next_ppdd_dt));
date_time_to_Arbdate(bill_cycle_struct->statement_date,
bill_cycle_struct->statement_time, &(bill_cycle_struct->statement_dt));
dbfcmd(dbproc1, " %t,", &(bill_cycle_struct->statement_dt));
date_time_to_Arbdate(bill_cycle_struct->cutoff_date,
bill_cycle_struct->cutoff_time, &(bill_cycle_struct->cutoff_dt));
dbfcmd(dbproc1, " %t,", &(bill_cycle_struct->cutoff_dt));
db_string =
(char *)convert_to_db_string(bill_cycle_struct->prep_delay);
dbfcmd(dbproc1, " %d)",atoi(db_string));
free(db_string);
if (safe_dbupdate(dbproc1, "BILL_CYCLE", "bill_cycle_save_db"))
{
return(FAILURE);
}
return(SUCCESS);
}
static int pdo_dblib_stmt_execute(pdo_stmt_t *stmt)
{
pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
pdo_dblib_db_handle *H = S->H;
RETCODE ret;
dbsetuserdata(H->link, (BYTE*) &S->err);
pdo_dblib_stmt_cursor_closer(stmt);
if (FAIL == dbcmd(H->link, stmt->active_query_string)) {
return 0;
}
if (FAIL == dbsqlexec(H->link)) {
return 0;
}
ret = pdo_dblib_stmt_next_rowset(stmt);
stmt->row_count = DBCOUNT(H->link);
stmt->column_count = dbnumcols(H->link);
return 1;
}
void Query::execute()
{
#ifdef MSSQL
dbcmd(this->connector->conn_ptr, this->query.c_str() );
if (dbsqlexec(this->connector->conn_ptr) == FAIL){
// commits query to db connection
status = false;
} else {
status = true;
}
#endif
#ifdef WATCHLIST_MYSQL
MYSQL *id = &(connector->mysqlID);
int stat = mysql_query(id, query.c_str());
string error;
if (stat){
this->setStatus(false);
this->setMessage(mysql_error(id));
} else {
this->setStatus(true);
}
#endif
}
int pp_mark_pkg_active( int pkg_id, int pkg_inst_id, int pkg_inst_id_serv)
{
int status;
RETCODE ret_code;
dbcmd (dbproc1, "EXEC pp_mark_pkg_active ");
dbfcmd(dbproc1, " @pkg_inst_id = %d, ", pkg_inst_id);
dbfcmd(dbproc1, " @pkg_inst_id_serv = %d ", pkg_inst_id_serv);
if(safe_dbexec(dbproc1,"MARK_PKG_ACTIVE", "mark_pkg_active"))
return(FAILURE);
while ((status = safe_dbresults (dbproc1, "MARK_PKG_ACTIVE", "mark_pkg_active")) != NO_MORE_RESULTS)
{
if (status == FAIL) return(FAILURE);
while ((ret_code = dbnextrow(dbproc1)) != NO_MORE_ROWS)
{
if(ret_code == FAIL) return(FAILURE);
/* process results */
}
}
return (SUCCESS);
}
int save_pid_to_db(int id,char* pd)
{
char szUsername[32] = "sa";
char szPassword[32]= "1qazxsw2*";
char szDBName[32] = "ids_db";
char szServer[32] = "10.2.10.201";
char sqlquery[1024]={0};
snprintf(sqlquery,1024,"update ids_policy_event set pid='%s' where id='%d'",pd,id);
dbinit();
LOGINREC *loginrec = dblogin();
DBSETLUSER(loginrec, szUsername);
DBSETLPWD(loginrec, szPassword);
DBPROCESS *dbprocess = dbopen(loginrec, szServer);
if(dbprocess == FAIL)
{
LOG_INFO(" Conect MS SQL SERVER fail ");
return -1;
}
if(dbuse(dbprocess, szDBName) == FAIL)
{
LOG_INFO(" Open database name fail");
return -1;
}
dbcmd(dbprocess,sqlquery);
if(dbsqlexec(dbprocess) == FAIL)
{
LOG_INFO("task.cpp dbsqlexec error!!!");
}
dbclose(dbprocess);
return 0;
}
int InsertSyncLog(COUPON_INFO_T *Data, int Count)
{
char sql_stm[SMALL_BUFF];
int i, count;
DBPROCESS *dbproc = ConnectDB();
memset(sql_stm, 0, SMALL_BUFF);
for(i = 0; i < Count; i++) {
sprintf(sql_stm, "Insert INTO T_CouponInfo_Compare2 (CouponNo, MemberCode, ProductCode, UsePeriod, ValidPeriod, StartDate, EndDate, UseDate, Status, RegDate) values ('%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s');",
Data[i].CouponID, Data[i].MemberCode, Data[i].ProductID,
Data[i].DueMonth, Data[i].ExpireMonth, Data[i].CreateDate,
Data[i].ExpireDate, Data[i].RegistDate, Data[i].Status,
Data[i].LastUpdateTimeStamp);
printLog(HEAD, "SQL::(%s)\n", sql_stm);
dbcmd(dbproc, sql_stm);
dbsqlexec(dbproc);
if((count = DBCOUNT(dbproc)) == 0) {
printLog(HEAD, "(%s) sql fail ..\n", sql_stm);
}
}
DisConnectDB();
return NO_ERROR;
}
static zend_long dblib_handle_doer(pdo_dbh_t *dbh, const char *sql, size_t sql_len)
{
pdo_dblib_db_handle *H = (pdo_dblib_db_handle *)dbh->driver_data;
RETCODE ret, resret;
dbsetuserdata(H->link, (BYTE*)&H->err);
if (FAIL == dbcmd(H->link, sql)) {
return -1;
}
if (FAIL == dbsqlexec(H->link)) {
return -1;
}
resret = dbresults(H->link);
if (resret == FAIL) {
return -1;
}
ret = dbnextrow(H->link);
if (ret == FAIL) {
return -1;
}
if (dbnumcols(H->link) <= 0) {
return DBCOUNT(H->link);
}
/* throw away any rows it might have returned */
dbcanquery(H->link);
return DBCOUNT(H->link);
}
/*
* Fill the command buffer from a file while echoing it to standard output.
*/
RETCODE
sql_cmd(DBPROCESS *dbproc)
{
char line[2048], *p = line;
int i = 0;
RETCODE erc=SUCCEED;
if (!input_file) {
fprintf(stderr, "%s: error: SQL input file \"%s\" not opened\n", BASENAME, sql_file);
exit(1);
}
while ((p = fgets(line, (int)sizeof(line), input_file)) != NULL && strcasecmp("go\n", p) != 0) {
printf("\t%3d: %s", ++i, p);
if ((erc = dbcmd(dbproc, p)) != SUCCEED) {
fprintf(stderr, "%s: error: could write \"%s\" to dbcmd()\n", BASENAME, p);
exit(1);
}
}
if (ferror(input_file)) {
fprintf(stderr, "%s: error: could not read SQL input file \"%s\"\n", BASENAME, sql_file);
exit(1);
}
return erc;
}
/*
*******************************************
* insert information
*******************************************
*/
int ext_socket_access_save_db(EXT_SOCKET_ACCESS_STRUCT *ext_socket_access_struct)
{
int i, ret_code;
int status;
char *db_string = NULL;
/*****************************************
Insert into EXT_SOCKET_ACCESS;
*****************************************/
dbcmd(dbproc1," insert into EXT_SOCKET_ACCESS ");
dbcmd(dbproc1, " (ext_contact_id,remote_host,ip_address,");
dbcmd(dbproc1, " port,timeout, eof_data)");
dbcmd(dbproc1, " values(");
db_string =
(char *)convert_to_db_string(ext_socket_access_struct->ext_contact_id);
dbfcmd(dbproc1, " %d,",atoi(db_string));
free(db_string);
db_string =
(char *)convert_to_db_string(ext_socket_access_struct->remote_host);
dbfcmd(dbproc1, " '%s',",db_string);
free(db_string);
db_string =
(char *)convert_to_db_string(ext_socket_access_struct->ip_address);
dbfcmd(dbproc1, " '%s',",db_string);
free(db_string);
db_string =
(char *)convert_to_db_string(ext_socket_access_struct->port);
dbfcmd(dbproc1, " %d,",atoi(db_string));
free(db_string);
db_string =
(char *)convert_to_db_string(ext_socket_access_struct->timeout);
dbfcmd(dbproc1, " %d,",atoi(db_string));
free(db_string);
db_string =
(char *)convert_to_db_string(ext_socket_access_struct->eof_data);
if (strlen(db_string) == 0)
dbfcmd(dbproc1, " NULL)",db_string);
else
dbfcmd(dbproc1, " %s)",db_string);
free(db_string);
if (safe_dbupdate(dbproc1, "EXT_SOCKET_ACCESS", "ext_socket_access_save_db"))
{
return(FAILURE);
}
return(SUCCESS);
}
int syb_exec_immediate (char *order)
{
DBPROCESS * dbp = descriptor[PRIVATE_DESCRIPTOR];
clear_error ();
dbcmd (dbp, order);
dbsqlexec (dbp);
return error_number;
}
static int
next_query(DBPROCESS *dbproc)
{
char query_line[4096];
RETCODE erc;
if (feof(stdin))
return -1;
fprintf(options.verbose, "%s:%d: Query:\n", options.appname, __LINE__);
/*
* Normally, a call to dbcmd() clears the buffer the first time it's
* invoked after a call to dbsqlexec() or dbsqlsend(). If fgets(3)
* returns 0 below, however, we'd indicate "success" without calling
* dbcmd(). This would leave the prior query in the buffer, which
* our caller would re-send. To avoid such nonsense, we invoke
* dbfreebuf() as a precaution.
*/
dbfreebuf(dbproc);
while (fgets(query_line, sizeof(query_line), stdin)) {
/* 'go' or 'GO' separates command batches */
const char *p = query_line;
/* Skip past leading white spaces */
while (isspace((unsigned char) *p))
p++;
if (strncasecmp(p, "go", 2) == 0) {
for (p+=2; isspace((unsigned char) *p); p++) {
if (*p == '\n')
return 1;
}
}
fprintf(options.verbose, "\t%s", query_line);
/* Add the query line to the command to be sent to the server */
erc = dbcmd(dbproc, query_line);
if (erc == FAIL) {
fprintf(stderr, "%s:%d: dbcmd() failed\n", options.appname, __LINE__);
return -1;
}
}
if (feof(stdin))
return dbstrlen(dbproc) > 0? 0 : -1;
if (ferror(stdin)) {
fprintf(stderr, "%s:%d: next_query() failed\n", options.appname, __LINE__);
perror(NULL);
return -1;
}
return 1;
}
int
delete_bill_cycle_db()
{
char *db_string;
int i = 0, ret_code;
dbcmd(dbproc1," delete BILL_CYCLE ");
dbcmd(dbproc1, " where ");
db_string =
(char *)convert_to_db_string(bill_cycle_selected.bill_period);
dbfcmd(dbproc1, " bill_period = '%s'",
db_string);
free(db_string);
db_string =
(char *)convert_to_db_string(bill_cycle_selected.billing_frequency);
dbfcmd(dbproc1, " and billing_frequency = %d",
atoi(db_string));
free(db_string);
date_time_to_Arbdate(bill_cycle_selected.next_ppdd_date,
bill_cycle_selected.next_ppdd_time,
&(bill_cycle_selected.next_ppdd_dt));
dbfcmd(dbproc1, " and next_ppdd_date = %t ",
&(bill_cycle_selected.next_ppdd_dt));
if(safe_dbupdate(dbproc1, "BILL_CYCLE",
"delete_bill_cycle_db"))
{
return(FAILURE);
}
while ((ret_code = dbnextrow(dbproc1)) == REG_ROW)
{
if (ret_code == FAIL)
{
return(FAILURE);
}
}
if(check_dbresults(dbproc1,ret_code,"BILL_CYCLE",
"delete_bill_cycle_db"))
return(FAILURE);
return(SUCCESS);
}
static void
query(const char *query)
{
printf("query: %s\n", query);
dbcmd(dbproc, (char *) query);
dbsqlexec(dbproc);
while (dbresults(dbproc) == SUCCEED) {
/* nop */
}
}
static void
char_test(const char *null, int bindlen, const char *expected)
{
char db_c[16];
RETCODE ret;
if (null) {
fprintf(stderr, "\tdbsetnull(CHARBIND, %u, '%s').\n", (unsigned int) strlen(null), null);
ret = dbsetnull(dbproc, CHARBIND, strlen(null), (BYTE *) null);
if (ret != SUCCEED) {
fprintf(stderr, "dbsetnull returned error %d\n", (int) ret);
failed = 1;
}
}
memset(db_c, '_', sizeof(db_c));
strcpy(db_c, "123456");
dbcmd(dbproc, "select convert(char(20), null)");
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
fprintf(stderr, "Was expecting a row.\n");
failed = 1;
dbcancel(dbproc);
}
fprintf(stderr, "dbbind(CHARBIND, bindlen= %d).\n", bindlen);
dbbind(dbproc, 1, CHARBIND, bindlen, (BYTE *) &db_c);
db_c[sizeof(db_c)-1] = 0;
printf("buffer before/after dbnextrow: '%s'/", db_c);
if (dbnextrow(dbproc) != REG_ROW) {
fprintf(stderr, "Was expecting a row.\n");
failed = 1;
dbcancel(dbproc);
}
db_c[sizeof(db_c)-1] = 0;
printf("'%s'\n", db_c);
if (dbnextrow(dbproc) != NO_MORE_ROWS) {
fprintf(stderr, "Only one row expected\n");
dbcancel(dbproc);
failed = 1;
}
while (dbresults(dbproc) == SUCCEED) {
/* nop */
}
if (strcmp(db_c, expected) != 0) {
fprintf(stderr, "Invalid NULL '%s' returned expected '%s' (%s:%d)\n", db_c, expected, tds_basename(__FILE__), __LINE__);
failed = 1;
}
}
RETCODE dbExecSql(const char * sql_str,DBPROCESS **db_proc)
{
RETCODE erc=-1;
dbcmd(*db_proc,sql_str);
if((erc=dbsqlexec(*db_proc))==FAIL)
{
fprintf(stderr, "%s:%d: exec sql:%s err\n", __func__, __LINE__,sql_str);
return erc;
}
return erc;
}
int pp_add_component (int comp_id,
int pkg_id,
int pkg_inst_id,
int pkg_inst_id_serv,
int level,
int id_value,
int subscr_no_resets,
int *comp_inst_id,
int *comp_inst_id_serv,
char *start_date,
int pkg_status)
{
int track_id;
int serv_id;
int status;
int ret_code;
dbcmd (dbproc1, "EXEC pp_add_component_to_pkg ");
dbfcmd(dbproc1, " @pkg_id = %d, ", pkg_id);
dbfcmd(dbproc1, " @pkg_inst_id = %d, ", pkg_inst_id);
dbfcmd(dbproc1, " @pkg_inst_id_serv = %d, ", pkg_inst_id_serv);
dbfcmd(dbproc1, " @pkg_status = %d, ",pkg_status );
dbfcmd(dbproc1, " @comp_id = %d, ", comp_id);
dbfcmd(dbproc1, " @id_type = %d, ", level);
dbfcmd(dbproc1, " @id_value = %d, ", id_value);
dbfcmd(dbproc1, " @subscr_no_resets = %d, ", subscr_no_resets);
dbfcmd(dbproc1, " @active_dt = '%s' ", start_date);
if(safe_dbexec(dbproc1,"INSERT_PKG", "insert_pkg"))
return(FAILURE);
while ((status = safe_dbresults (dbproc1, "INSERT_PKG", "insert_pkg")) != NO_MORE_RESULTS)
{
if (status == FAIL)
return(FAILURE);
dbbind (dbproc1, 1, INTBIND, 0, &track_id);
dbbind (dbproc1, 2, INTBIND, 0, &serv_id);
while ((ret_code = dbnextrow(dbproc1)) != NO_MORE_ROWS)
{
if(ret_code == FAIL)
return(FAILURE);
/* process results */
*comp_inst_id = track_id;
*comp_inst_id_serv = serv_id;
}
}
return (SUCCESS);
}
int
delete_ext_socket_access_db()
{
char *db_string;
int i = 0, ret_code;
dbcmd(dbproc1," delete EXT_SOCKET_ACCESS ");
dbcmd(dbproc1, " where ");
db_string =
(char *)convert_to_db_string(ext_socket_access_selected.ext_contact_id);
dbfcmd(dbproc1, " ext_contact_id = %d",
atoi(db_string));
free(db_string);
if(safe_dbupdate(dbproc1, "EXT_SOCKET_ACCESS",
"delete_ext_socket_access_db"))
{
return(FAILURE);
}
return(SUCCESS);
}
static int pdo_dblib_transaction_cmd(const char *cmd, pdo_dbh_t *dbh)
{
pdo_dblib_db_handle *H = (pdo_dblib_db_handle *)dbh->driver_data;
if (FAIL == dbcmd(H->link, cmd)) {
return 0;
}
if (FAIL == dbsqlexec(H->link)) {
return 0;
}
return 1;
}
int
delete_rate_usage_or_db()
{
int i = 0, ret_code;
dbcancel(dbproc1);
if(begin_tran(dbproc1,"DELETE_RATE_USAGE_OVERRIDES") == FAILURE)
return(FAILURE);
dbcmd(dbproc1," delete RATE_USAGE_BANDS_OVERRIDES ");
dbfcmd(dbproc1," where seqnum = %s ",rate_usage_or_selected.seqnum);
if(safe_dbupdate(dbproc1, "RATE_USAGE_BANDS_OVERRIDES",
"delete_rate_usage_or_db"))
{
(void)rollback_tran(dbproc1, "delete_rate_usage_or_db");
dbcancel(dbproc1);
return(FAILURE);
}
dbcmd(dbproc1," delete RATE_USAGE_OVERRIDES ");
dbfcmd(dbproc1, " where seqnum = %s ",rate_usage_or_selected.seqnum);
if(safe_dbupdate(dbproc1, "RATE_USAGE_OVERRIDES",
"delete_rate_usage_or_db"))
{
(void)rollback_tran(dbproc1, "delete_rate_usage_or_db");
dbcancel(dbproc1);
return(FAILURE);
}
/* ************************ */
(void)commit_tran(dbproc1); /* ** COMMIT TRANSACTION ** */
/* ************************ */
return(SUCCESS);
}
void print_ort(void){
/*anzeige aller berufe*/
dbcmd(dbproc,"SELECT Ort FROM Mitarbeiter group by Ort");
dbsqlexec(dbproc);
while (dbresults(dbproc)!=NO_MORE_RESULTS)
{
dbbind(dbproc,1,NTBSTRINGBIND,0,Ort);
while (dbnextrow(dbproc)!=NO_MORE_ROWS)
{
printf(": %s\n",Mitarbeiter);
}
}
}
QTDSResult::QTDSResult(const QTDSDriver* db)
: QSqlCachedResult(db)
{
d = new QTDSResultPrivate();
d->login = db->d->login;
d->dbproc = dbopen(d->login, const_cast<char*>(db->d->hostName.toLatin1().constData()));
if (!d->dbproc)
return;
if (dbuse(d->dbproc, const_cast<char*>(db->d->db.toLatin1().constData())) == FAIL)
return;
// insert d in error handler dict
errs()->insert(d->dbproc, d);
dbcmd(d->dbproc, "set quoted_identifier on");
dbsqlexec(d->dbproc);
}
static VALUE rb_tinytds_execute(VALUE self, VALUE sql) {
GET_CLIENT_WRAPPER(self);
rb_tinytds_client_reset_userdata(cwrap->userdata);
REQUIRE_OPEN_CLIENT(cwrap);
dbcmd(cwrap->client, StringValuePtr(sql));
if (dbsqlsend(cwrap->client) == FAIL) {
rb_warn("TinyTds: dbsqlsend() returned FAIL.\n");
return Qfalse;
}
cwrap->userdata->dbsql_sent = 1;
VALUE result = rb_tinytds_new_result_obj(cwrap);
rb_iv_set(result, "@query_options", rb_funcall(rb_iv_get(self, "@query_options"), intern_dup, 0));
GET_RESULT_WRAPPER(result);
rwrap->local_offset = rb_funcall(cTinyTdsClient, intern_local_offset, 0);
rwrap->encoding = cwrap->encoding;
return result;
}
