static void test0(int n, const char * expected) { DBINT ind, expected_ind; char text_buf[16]; dbfcmd(dbproc, "select c from #null where n = %d", n); dbsqlexec(dbproc); if (dbresults(dbproc) != SUCCEED) { fprintf(stderr, "Was expecting a row.\n"); failed = 1; dbcancel(dbproc); return; } dbbind(dbproc, 1, NTBSTRINGBIND, 0, (BYTE *)text_buf); if (use_nullbind) dbnullbind(dbproc, 1, &ind); memset(text_buf, 'a', sizeof(text_buf)); ind = -5; if (dbnextrow(dbproc) != REG_ROW) { fprintf(stderr, "Was expecting a row.\n"); failed = 1; dbcancel(dbproc); return; } text_buf[sizeof(text_buf) - 1] = 0; printf("ind %d text_buf -%s-\n", (int) ind, text_buf); expected_ind = 0; if (strcmp(expected, "aaaaaaaaaaaaaaa") == 0) expected_ind = -1; /* do not check indicator if not bound */ if (!use_nullbind) ind = expected_ind; if (ind != expected_ind || strcmp(expected, text_buf) != 0) { fprintf(stderr, "expected_ind %d expected -%s-\n", (int) expected_ind, expected); failed = 1; dbcancel(dbproc); return; } if (dbnextrow(dbproc) != NO_MORE_ROWS) { fprintf(stderr, "Only one row expected\n"); dbcancel(dbproc); failed = 1; } 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; } }
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 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 pp_add_inactive_pkg (int pkg_id, int *pkg_inst_id, int *pkg_inst_id_serv, char *start_date) { int track_id; int serv_id; int status; int ret_code; dbfcmd(dbproc1, "exec pp_insert_inactive_pkg @account_no = %d,",gaccount_no); dbfcmd(dbproc1, " @pkg_id = %d, ", pkg_id); 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 */ *pkg_inst_id = track_id; *pkg_inst_id_serv = serv_id; } } return (SUCCESS); }
int verify_terminate (int *ok_to_terminate) { RETCODE ret_code; dbfcmd(dbproc1, "EXEC csr_verify_acct_terminate @account_no = %d", gaccount_no); 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, INTBIND, 0, ok_to_terminate); while (dbnextrow(dbproc1) != NO_MORE_ROWS); /* empty */ } if (Sybase_error) { dbcancel(dbproc1); return(FAILURE); } return (SUCCESS); } /* end verify_terminate */
static int init(DBPROCESS * dbproc, const char *name) { int res = 0; RETCODE rc; fprintf(stdout, "Dropping %s.%s..%s\n", SERVER, DATABASE, name); sql_cmd(dbproc); dbsqlexec(dbproc); while ((rc=dbresults(dbproc)) == SUCCEED) { /* nop */ } if (rc != NO_MORE_RESULTS) return 1; fprintf(stdout, "Creating %s.%s..%s\n", SERVER, DATABASE, name); sql_cmd(dbproc); sql_cmd(dbproc); if (dbsqlexec(dbproc) == FAIL) { res = 1; } while ((rc=dbresults(dbproc)) == SUCCEED) { dbprhead(dbproc); dbprrow(dbproc); while ((rc=dbnextrow(dbproc)) == REG_ROW) { dbprrow(dbproc); } } if (rc != NO_MORE_RESULTS) return 1; fprintf(stdout, "%s\n", res? "error" : "ok"); 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 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 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); }
bool CDBL_ComputeResult::Fetch() { if (m_1stFetch) { // we didn't get the items yet; m_1stFetch = false; m_CurrItem= 0; return true; } STATUS s = Check(dbnextrow(GetCmd())); switch (s) { case REG_ROW: case NO_MORE_ROWS: *m_ResStatus ^= 0x10; break; case FAIL: DATABASE_DRIVER_ERROR( "Error in fetching row." + GetDbgInfo(), 270003 ); case BUF_FULL: DATABASE_DRIVER_ERROR( "Buffer is full." + GetDbgInfo(), 270006 ); default: break; } m_EOR = true; m_CurrItem= -1; return false; }
void get_all(char *mitnr_in) { dbfcmd(dbproc,"SELECT m.Name, m.Vorname, m.Ort, m.Gebdat, m.Beruf, m.Telnr, mp.Istvzae, mp.Planvzae, p.Proname FROM Mitarbeiter m, MiPro mp, Projekt p WHERE m.Mitnr = mp.Mitnr AND mp.Pronr = p.Pronr AND m.Mitnr = '%s'", mitnr_in); dbsqlexec(dbproc); while (dbresults(dbproc)!=NO_MORE_RESULTS) { i=0; dbbind(dbproc,1,NTBSTRINGBIND,0,name); dbbind(dbproc,2,NTBSTRINGBIND,0,vorname); dbbind(dbproc,3,NTBSTRINGBIND,0,ort); dbbind(dbproc,4,DATETIMEBIND,0,(BYTE *)&gebdat); dbbind(dbproc,5,NTBSTRINGBIND,0,beruf); dbbind(dbproc,6,NTBSTRINGBIND,0,telnr); dbbind(dbproc,7,FLT8BIND,0,(BYTE *)&istvzae); dbbind(dbproc,8,FLT8BIND,0,(BYTE *)&planvzae); dbbind(dbproc,9,NTBSTRINGBIND,0,proname); while (dbnextrow(dbproc)!=NO_MORE_ROWS) { printf("%d:\t%s,\t%s,\t%s,\t%s,\t%s,\t%s,\t%f,\t%f,\t%s,\n",i, name, vorname, ort, date_to_str(gebdat), beruf, telnr, istvzae, planvzae, proname); i++; } } }
static int select_rows(DBPROCESS * dbproc, int bind_type) { char teststr[1024]; char teststr2[1024]; char testvstr[1024]; DBINT testint; DBINT i; printf("select\n"); sql_cmd(dbproc); dbsqlexec(dbproc); if (dbresults(dbproc) != SUCCEED) { failed = 1; printf("Was expecting a result set."); exit(1); } for (i = 1; i <= dbnumcols(dbproc); i++) { printf("col %d is %s\n", i, dbcolname(dbproc, i)); } if (SUCCEED != dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint)) { fprintf(stderr, "Had problem with bind\n"); return 1; } if (SUCCEED != dbbind(dbproc, 2, bind_type, 0, (BYTE *) teststr)) { fprintf(stderr, "Had problem with bind\n"); return 1; } if (SUCCEED != dbbind(dbproc, 3, bind_type, 0, (BYTE *) teststr2)) { fprintf(stderr, "Had problem with bind\n"); return 1; } if (SUCCEED != dbbind(dbproc, 4, bind_type, 0, (BYTE *) testvstr)) { fprintf(stderr, "Had problem with bind\n"); return 1; } i = 0; while (dbnextrow(dbproc) == REG_ROW) { i++; if (testint != i) { printf("Failed. Expected i to be |%d|, was |%d|\n", testint, i); return 1; } printf("c: %s$\n", teststr); printf("c2: %s$\n", teststr2); printf("vc: %s$\n", testvstr); if (bind_type == STRINGBIND) { } else { } } return 0; }
bool QTDSResult::gotoNext(QSqlCachedResult::ValueCache &values, int index) { STATUS stat = dbnextrow(d->dbproc); if (stat == NO_MORE_ROWS) { setAt(QSql::AfterLastRow); return false; } if ((stat == FAIL) || (stat == BUF_FULL)) { setLastError(d->lastError); return false; } if (index < 0) return true; for (int i = 0; i < d->rec.count(); ++i) { int idx = index + i; switch (d->rec.field(i).type()) { case QVariant::DateTime: if (qIsNull(d->buffer.at(i * 2 + 1))) { values[idx] = QVariant(QVariant::DateTime); } else { DBDATETIME *bdt = (DBDATETIME*) d->buffer.at(i * 2); QDate date = QDate::fromString(QLatin1String("1900-01-01"), Qt::ISODate); QTime time = QTime::fromString(QLatin1String("00:00:00"), Qt::ISODate); values[idx] = QDateTime(date.addDays(bdt->dtdays), time.addMSecs(int(bdt->dttime / 0.3))); } break; case QVariant::Int: if (qIsNull(d->buffer.at(i * 2 + 1))) values[idx] = QVariant(QVariant::Int); else values[idx] = *((int*)d->buffer.at(i * 2)); break; case QVariant::Double: case QVariant::String: if (qIsNull(d->buffer.at(i * 2 + 1))) values[idx] = QVariant(QVariant::String); else values[idx] = QString::fromLocal8Bit((const char*)d->buffer.at(i * 2)).trimmed(); break; case QVariant::ByteArray: { if (qIsNull(d->buffer.at(i * 2 + 1))) values[idx] = QVariant(QVariant::ByteArray); else values[idx] = QByteArray((const char*)d->buffer.at(i * 2)); break; } default: // should never happen, and we already fired // a warning while binding. values[idx] = QVariant(); break; } } return true; }
void Query::execute( Connector *conn, string s_query) { this->connector = conn; this->query = s_query; this->execute(); logger->debug("connector: %p, executing query: %s\n", conn, s_query.c_str()); if (!this->getStatus()){ logger->debug("Query failed.\n "); } else { logger->debug("fetching results..\n"); fetch_results(); bind_variables();// allocating and binding variables for iteration vector<field>::iterator iter_f = v_fields.begin(); #ifdef MSSQL while (dbnextrow(conn->conn_ptr) != NO_MORE_ROWS){ iter_f = v_fields.begin(); while(iter_f!=v_fields.end()){ if(iter_f->type!=field::TYPE_INT) stripSpace(iter_f->data, iter_f->size); iter_f++; } num_records++; iterate(v_fields); } #endif #ifdef WATCHLIST_MYSQL if (res != NULL){// insert or update queries. this->num_records = mysql_num_rows(res); MYSQL_ROW row; int pos; if (res !=NULL && (num_records > 0)) while( ( row = mysql_fetch_row(res))){ // fetch each records pos = 0; iter_f = v_fields.begin(); while(iter_f!=v_fields.end()){ // iterating columns if (iter_f->type==field::TYPE_INT){ iter_f->setData(atoi(row[pos])); } else { iter_f->setData(string(row[pos])); } pos++; iter_f++; } iterate(v_fields);// passing to child } mysql_free_result(res); } #endif } logger->debug("completed execute\n"); }
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 main(int argc, char *argv[]) { LOGINREC *login; DBPROCESS *dbproc; int ret_code; int num_cols; int num_res; set_malloc_options(); read_login_info(argc, argv); printf("Starting %s\n", argv[0]); dbinit(); dberrhandle(syb_err_handler); dbmsghandle(syb_msg_handler); printf("About to logon\n"); login = dblogin(); DBSETLPWD(login, PASSWORD); DBSETLUSER(login, USER); DBSETLAPP(login, "t0012"); dbproc = dbopen(login, SERVER); if (strlen(DATABASE)) { dbuse(dbproc, DATABASE); } dbloginfree(login); printf("After logon\n"); /* select */ sql_cmd(dbproc); dbsqlexec(dbproc); num_res = 0; while ((ret_code = dbresults(dbproc)) == SUCCEED) { num_cols = dbnumcols(dbproc); printf("Result %d has %d columns\n", num_res, num_cols); if (!(num_res % 2) && num_cols) set_failed(); while(dbnextrow(dbproc) != NO_MORE_ROWS) {}; num_res++; } if (ret_code == FAIL) set_failed(); dbclose(dbproc); dbexit(); printf("%s %s\n", __FILE__, (failed ? "failed!" : "OK")); return failed ? 1 : 0; }
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_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); }
int syb_next_row (int no_des) /* move to the next row of selection */ /* return 0 if there is a next row, 1 if no row left */ { clear_error (); error_number = dbnextrow (descriptor[no_des]); if (error_number == NO_MORE_ROWS) { return 1; } else { return 0; } }
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); } } }
void get_berufe() { dbcmd(dbproc,"SELECT Beruf FROM Mitarbeiter GROUP BY Beruf"); dbsqlexec(dbproc); while (dbresults(dbproc)!=NO_MORE_RESULTS) { i=0; dbbind(dbproc,1,NTBSTRINGBIND,15,beruf); while (dbnextrow(dbproc)!=NO_MORE_ROWS) { printf("%d: %s\n",i, beruf); i++; } } }
void insert_lebenslauf(void){ /*anzeige aller berufe*/ dbcmd(dbproc,"SELECT Lebenslauf FROM Mitarbeiter"); dbsqlexec(dbproc); while (dbresults(dbproc)!=NO_MORE_RESULTS) { dbbind(dbproc,1,STRINGBIND,0,abstract_var); while (dbnextrow(dbproc)!=NO_MORE_ROWS) { strcpy(abstract_var, "Hauptschule"); dbwritetext(dbproc_insert, "Mitarbeiter.Lebenslauf", dbtxptr(dbproc, 1), DBTXPLEN, dbtxtimestamp(dbproc,1),TRUE, (DBINT)strlen(abstract_var),abstract_var); } } }
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); }
char *dblib_handle_last_id(pdo_dbh_t *dbh, const char *name, size_t *len) { pdo_dblib_db_handle *H = (pdo_dblib_db_handle *)dbh->driver_data; RETCODE ret; char *id = NULL; /* * Would use scope_identity() but it's not implemented on Sybase */ if (FAIL == dbcmd(H->link, "SELECT @@IDENTITY")) { return NULL; } if (FAIL == dbsqlexec(H->link)) { return NULL; } ret = dbresults(H->link); if (ret == FAIL || ret == NO_MORE_RESULTS) { dbcancel(H->link); return NULL; } ret = dbnextrow(H->link); if (ret == FAIL || ret == NO_MORE_ROWS) { dbcancel(H->link); return NULL; } if (dbdatlen(H->link, 1) == 0) { dbcancel(H->link); return NULL; } id = emalloc(32); *len = dbconvert(NULL, (dbcoltype(H->link, 1)) , (dbdata(H->link, 1)) , (dbdatlen(H->link, 1)), SQLCHAR, (BYTE *)id, (DBINT)-1); dbcancel(H->link); return id; }
static int dbd_freetds_get_row(apr_pool_t *pool, apr_dbd_results_t *res, apr_dbd_row_t **rowp, int rownum) { RETCODE rv = 0; apr_dbd_row_t *row = *rowp; int sequential = ((rownum >= 0) && res->random) ? 0 : 1; if (row == NULL) { row = apr_palloc(pool, sizeof(apr_dbd_row_t)); *rowp = row; row->res = res; } /* else { if ( sequential ) { ++row->n; } else { row->n = rownum; } } */ if (sequential) { rv = dbnextrow(res->proc); } else { rv = (rownum >= 0) ? dbgetrow(res->proc, rownum) : NO_MORE_ROWS; } switch (rv) { case SUCCEED: return 0; case REG_ROW: return 0; case NO_MORE_ROWS: apr_pool_cleanup_run(res->pool, res->proc, clear_result); *rowp = NULL; return -1; case FAIL: return 1; case BUF_FULL: return 2; /* FIXME */ default: return 3; } return 0; }
void get_mitarbeiter(char *beruf_in) { dbfcmd(dbproc,"SELECT Mitnr, Name, Vorname FROM Mitarbeiter WHERE Beruf = '%s'", beruf_in); dbsqlexec(dbproc); while (dbresults(dbproc)!=NO_MORE_RESULTS) { i=0; dbbind(dbproc,1,NTBSTRINGBIND,5,mitnr); dbbind(dbproc,2,NTBSTRINGBIND,10,name); dbbind(dbproc,3,NTBSTRINGBIND,10,vorname); while (dbnextrow(dbproc)!=NO_MORE_ROWS) { printf("%d:\t%s,\t%s,\t%s\n",i, mitnr, name, vorname); i++; } } }
static int pdo_dblib_stmt_next_rowset(pdo_stmt_t *stmt) { pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data; pdo_dblib_db_handle *H = S->H; RETCODE ret = SUCCESS; /* Ideally use dbcanquery here, but there is a bug in FreeTDS's implementation of dbcanquery * It has been resolved but is currently only available in nightly builds */ while (NO_MORE_ROWS != ret) { ret = dbnextrow(H->link); if (FAIL == ret) { pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO_DBLIB: dbnextrow() returned FAIL"); return 0; } } return pdo_dblib_stmt_next_rowset_no_cancel(stmt); }
int BCPInRecords(ifstream bcpInfile, char *szExtSystem) { int intImportCount = 0; // Get current server datetime DBDATETIME dtCurDateTime; dtCurDateTime.dtdays = 0; dbcmd(dbproc, "select getdate()"); dbsqlexec(dbproc); if (dbresults(dbproc) == SUCCEED) if (dbnextrow(dbproc) != NO_MORE_ROWS) dbconvert(dbproc, SYBDATETIME, (dbdata(dbproc, 1)), (DBINT)-1, SYBDATETIME, (BYTE*)&dtCurDateTime, (DBINT)-1); if ( dtCurDateTime.dtdays == 0 ) return -1; // Call bcp_init if ( bcp_init(dbproc, "cags..x_import", NULL, "bcp_err.out", DB_IN) != SUCCEED ) { errfile << ERROR_PREFIX << "failed bcp_init" << endl; return -1; } bcp_bind(dbproc, (BYTE*)szExtSystem, 0, -1, (BYTE*)"", 1, SYBCHAR, 1); bcp_bind(dbproc, (BYTE*)&dtCurDateTime, 0, -1, NULL, 0, SYBDATETIME, 2); bcp_bind(dbproc, (BYTE*)&intImportCount, 0, -1, NULL, 0, SYBINT2, 3); bcp_bind(dbproc, (BYTE*)buffer, 0, -1, (BYTE*)"", 1, SYBVARCHAR, 4); while ( !bcpInfile.eof() ) { bcpInfile.getline(buffer, 255); // cout << buffer << endl; intImportCount++; // Bulk copy it into the database */ bcp_sendrow(dbproc); } // Close the bulk copy process so all the changes are committed return bcp_done(dbproc); }