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;
}
static RETCODE
init_proc(DBPROCESS * dbproc, const char *name)
{
RETCODE ret = FAIL;
if (name[0] != '#') {
printf("Dropping procedure %s\n", name);
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
printf("Creating procedure %s\n", name);
sql_cmd(dbproc);
if ((ret = dbsqlexec(dbproc)) == FAIL) {
if (name[0] == '#')
printf("Failed to create procedure %s. Wrong permission or not MSSQL.\n", name);
else
printf("Failed to create procedure %s. Wrong permission.\n", name);
}
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
return ret;
}
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;
}
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;
}
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
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
read_login_info(argc, argv);
printf("Starting %s\n", argv[0]);
dbinit();
printf("About to logon\n");
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0011");
printf("About to open\n");
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
printf("Dropping table\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
printf("creating table\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
printf("insert\n");
insert_row(dbproc);
insert_row(dbproc);
insert_row(dbproc);
failed = select_rows(dbproc, STRINGBIND);
dbexit();
printf("%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
static int
start_query(DBPROCESS * dbproc)
{
int i;
if (SUCCEED != sql_cmd(dbproc)) {
return 0;
}
if (SUCCEED != dbsqlexec(dbproc)) {
return 0;
}
add_bread_crumb();
if (dbresults(dbproc) != SUCCEED) {
add_bread_crumb();
return 0;
}
add_bread_crumb();
for (i = 1; i <= dbnumcols(dbproc); i++) {
add_bread_crumb();
printf("col %d is named \"%s\"\n", i, dbcolname(dbproc, i));
add_bread_crumb();
}
return 1;
}
static int pdo_dblib_stmt_next_rowset_no_cancel(pdo_stmt_t *stmt)
{
pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
pdo_dblib_db_handle *H = S->H;
RETCODE ret;
int num_fields;
do {
ret = dbresults(H->link);
num_fields = dbnumcols(H->link);
} while (H->skip_empty_rowsets && num_fields <= 0 && ret == SUCCEED);
if (FAIL == ret) {
pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO_DBLIB: dbresults() returned FAIL");
return 0;
}
if (NO_MORE_RESULTS == ret) {
return 0;
}
if (H->skip_empty_rowsets && num_fields <= 0) {
return 0;
}
stmt->row_count = DBCOUNT(H->link);
stmt->column_count = num_fields;
return 1;
}
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);
}
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 */
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;
}
static void
insert_row(DBPROCESS * dbproc)
{
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
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;
}
}
static void
query(const char *query)
{
printf("query: %s\n", query);
dbcmd(dbproc, (char *) query);
dbsqlexec(dbproc);
while (dbresults(dbproc) == SUCCEED) {
/* nop */
}
}
void Query::fetch_results()
{
#ifdef MSSQL
dbresults(this->connector->conn_ptr);
#endif
#ifdef WATCHLIST_MYSQL
res = mysql_store_result(&(this->connector->mysqlID));
#endif
}
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 syb_results_order (int no_des)
{
DBPROCESS * dbp = descriptor[no_des];
clear_error ();
while (dbresults (dbp) != NO_MORE_RESULTS)
{
/* empty */
}
return error_number;
}
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;
}
static void
create_tables(DBPROCESS * dbproc, int rows_to_add)
{
int i;
fprintf(stdout, "creating table\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "insert\n");
for (i = 1; i < rows_to_add; i++) {
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
}
static void
drop_table(void)
{
if (!dbproc)
return;
dbcancel(dbproc);
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
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);
}
}
}
static void
test(const char *type, int give_err)
{
RETCODE ret;
query("if object_id('#null') is not NULL drop table #null");
dberrhandle(ignore_err_handler);
dbmsghandle(ignore_msg_handler);
printf("create table #null (n int, c %s NULL)\n", type);
dbfcmd(dbproc, "create table #null (n int, c %s NULL)", type);
dbsqlexec(dbproc);
ret = dbresults(dbproc);
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
if (ret != SUCCEED) {
dbcancel(dbproc);
if (!give_err)
return;
fprintf(stdout, "Was expecting a result set.\n");
failed = 1;
return;
}
query("insert into #null values(1, '')");
query("insert into #null values(2, NULL)");
query("insert into #null values(3, ' ')");
query("insert into #null values(4, 'foo')");
use_nullbind = 1;
test0(1, "");
test0(2, "aaaaaaaaaaaaaaa");
test0(3, "");
test0(4, "foo");
use_nullbind = 0;
test0(1, "");
test0(2, "");
test0(3, "");
test0(4, "foo");
query("drop table #null");
}
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);
}
}
}
/* execute a query that doesn't return a result set, mop up,
* and return and APR-flavoured status
*/
static RETCODE freetds_exec(DBPROCESS *proc, const char *query,
int want_results, int *nrows)
{
/* TBD */
RETCODE rv = dbcmd(proc, query);
if (rv != SUCCEED) {
return rv;
}
rv = dbsqlexec(proc);
if (rv != SUCCEED) {
return rv;
}
if (!want_results) {
while (dbresults(proc) != NO_MORE_RESULTS) {
++*nrows;
}
}
return SUCCEED;
}
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;
}
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++;
}
}
}
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);
}
