Example #1
0
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 */
	}
}
Example #2
0
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;
	}
}
Example #3
0
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);
}
Example #6
0
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 */
Example #7
0
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;
}
Example #8
0
/* 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);
}
Example #9
0
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);
}
Example #10
0
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);
}
Example #11
0
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;
}
Example #12
0
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++;
    }
  }

}
Example #13
0
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;
}
Example #14
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;
}
Example #15
0
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;
  }
}
Example #17
0
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 */
Example #18
0
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);
}
Example #20
0
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);
}
Example #21
0
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;
    }
}
Example #22
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);
		 }
	}

}
Example #23
0
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++;
    }
  }
}
Example #24
0
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);
		}
	}

}
Example #25
0
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);
}
Example #26
0
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;
}
Example #27
0
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;
}
Example #28
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++;
    }
  }
}
Example #29
0
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);
}
Example #30
0
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);		
}