│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + 307buffer_transfer_bound_data(DBPROC_ROWBUF *buf, TDS_INT res_type, TDS_INT compute_id, DBPROCESS * dbproc, int idx)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ + 313 tdsdump_log(TDS_DBG_FUNC, "buffer_transfer_bound_data(%p %d %d %p %d)\n", buf, res_type, compute_id, dbproc, idx);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +RETCODE dbgetnull(DBPROCESS *dbproc, int bindtype, int varlen, BYTE *varaddr)
Definition dblib.c:529
TDSRET tds_alloc_row(TDSRESULTINFO *res_info)
Allocate space for row store return NULL on out of memory.
Definition mem.c:524
Definition buffering.h:1
unsigned char * row_data
row data, NULL for resinfo->current_row
Definition buffering.h:5
TDSRESULTINFO * resinfo
pointer to result informations
Definition buffering.h:3
Definition dblib.h:52
Definition dblib.h:123
TDS_SERVER_TYPE column_type
This type can be different from wire type because conversion (e.g.
Definition tds.h:696
TDS_INT column_cur_size
size written in variable (ie: char, text, binary).
Definition tds.h:736
│ │ │ │ Generated by
1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,386 +1,545 @@
│ │ │ │ │ FreeTDS API
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _s_r_c
│ │ │ │ │ - * _t_d_s
│ │ │ │ │ -num_limits.h
│ │ │ │ │ -1#define LIMIT_INDEXES_ADJUST 4
│ │ │ │ │ -2
│ │ │ │ │ -3static const signed char limit_indexes[79]= {
│ │ │ │ │ -4 0, /* 0 */
│ │ │ │ │ -5 -3, /* 1 */
│ │ │ │ │ -6 -6, /* 2 */
│ │ │ │ │ -7 -9, /* 3 */
│ │ │ │ │ -8 -12, /* 4 */
│ │ │ │ │ -9 -15, /* 5 */
│ │ │ │ │ -10 -18, /* 6 */
│ │ │ │ │ -11 -21, /* 7 */
│ │ │ │ │ -12 -24, /* 8 */
│ │ │ │ │ -13 -27, /* 9 */
│ │ │ │ │ -14 -30, /* 10 */
│ │ │ │ │ -15 -32, /* 11 */
│ │ │ │ │ -16 -34, /* 12 */
│ │ │ │ │ -17 -36, /* 13 */
│ │ │ │ │ -18 -38, /* 14 */
│ │ │ │ │ -19 -40, /* 15 */
│ │ │ │ │ -20 -42, /* 16 */
│ │ │ │ │ -21 -44, /* 17 */
│ │ │ │ │ -22 -46, /* 18 */
│ │ │ │ │ -23 -48, /* 19 */
│ │ │ │ │ -24 -50, /* 20 */
│ │ │ │ │ -25 -51, /* 21 */
│ │ │ │ │ -26 -52, /* 22 */
│ │ │ │ │ -27 -53, /* 23 */
│ │ │ │ │ -28 -54, /* 24 */
│ │ │ │ │ -29 -55, /* 25 */
│ │ │ │ │ -30 -56, /* 26 */
│ │ │ │ │ -31 -57, /* 27 */
│ │ │ │ │ -32 -58, /* 28 */
│ │ │ │ │ -33 -59, /* 29 */
│ │ │ │ │ -34 -59, /* 30 */
│ │ │ │ │ -35 -59, /* 31 */
│ │ │ │ │ -36 -59, /* 32 */
│ │ │ │ │ -37 -60, /* 33 */
│ │ │ │ │ -38 -61, /* 34 */
│ │ │ │ │ -39 -62, /* 35 */
│ │ │ │ │ -40 -63, /* 36 */
│ │ │ │ │ -41 -64, /* 37 */
│ │ │ │ │ -42 -65, /* 38 */
│ │ │ │ │ -43 -66, /* 39 */
│ │ │ │ │ -44 -66, /* 40 */
│ │ │ │ │ -45 -66, /* 41 */
│ │ │ │ │ -46 -66, /* 42 */
│ │ │ │ │ -47 -66, /* 43 */
│ │ │ │ │ -48 -66, /* 44 */
│ │ │ │ │ -49 -66, /* 45 */
│ │ │ │ │ -50 -66, /* 46 */
│ │ │ │ │ -51 -66, /* 47 */
│ │ │ │ │ -52 -66, /* 48 */
│ │ │ │ │ -53 -66, /* 49 */
│ │ │ │ │ -54 -65, /* 50 */
│ │ │ │ │ -55 -64, /* 51 */
│ │ │ │ │ -56 -63, /* 52 */
│ │ │ │ │ -57 -62, /* 53 */
│ │ │ │ │ -58 -61, /* 54 */
│ │ │ │ │ -59 -60, /* 55 */
│ │ │ │ │ -60 -59, /* 56 */
│ │ │ │ │ -61 -58, /* 57 */
│ │ │ │ │ -62 -57, /* 58 */
│ │ │ │ │ -63 -55, /* 59 */
│ │ │ │ │ -64 -53, /* 60 */
│ │ │ │ │ -65 -51, /* 61 */
│ │ │ │ │ -66 -49, /* 62 */
│ │ │ │ │ -67 -47, /* 63 */
│ │ │ │ │ -68 -45, /* 64 */
│ │ │ │ │ -69 -44, /* 65 */
│ │ │ │ │ -70 -43, /* 66 */
│ │ │ │ │ -71 -42, /* 67 */
│ │ │ │ │ -72 -41, /* 68 */
│ │ │ │ │ -73 -39, /* 69 */
│ │ │ │ │ -74 -37, /* 70 */
│ │ │ │ │ -75 -35, /* 71 */
│ │ │ │ │ -76 -33, /* 72 */
│ │ │ │ │ -77 -31, /* 73 */
│ │ │ │ │ -78 -29, /* 74 */
│ │ │ │ │ -79 -27, /* 75 */
│ │ │ │ │ -80 -25, /* 76 */
│ │ │ │ │ -81 -23, /* 77 */
│ │ │ │ │ -82 -21, /* 78 */
│ │ │ │ │ -83};
│ │ │ │ │ -84
│ │ │ │ │ -85static const TDS_WORD limits[]= {
│ │ │ │ │ -86 0x00000001u, /* 0 */
│ │ │ │ │ -87 0x0000000au, /* 1 */
│ │ │ │ │ -88 0x00000064u, /* 2 */
│ │ │ │ │ -89 0x000003e8u, /* 3 */
│ │ │ │ │ -90 0x00002710u, /* 4 */
│ │ │ │ │ -91 0x000186a0u, /* 5 */
│ │ │ │ │ -92 0x000f4240u, /* 6 */
│ │ │ │ │ -93 0x00989680u, /* 7 */
│ │ │ │ │ -94 0x05f5e100u, /* 8 */
│ │ │ │ │ -95 0x3b9aca00u, /* 9 */
│ │ │ │ │ -96 0x00000002u, /* 10 */
│ │ │ │ │ -97 0x540be400u, /* 11 */
│ │ │ │ │ -98 0x00000017u, /* 12 */
│ │ │ │ │ -99 0x4876e800u, /* 13 */
│ │ │ │ │ -100 0x000000e8u, /* 14 */
│ │ │ │ │ -101 0xd4a51000u, /* 15 */
│ │ │ │ │ -102 0x00000918u, /* 16 */
│ │ │ │ │ -103 0x4e72a000u, /* 17 */
│ │ │ │ │ -104 0x00005af3u, /* 18 */
│ │ │ │ │ -105 0x107a4000u, /* 19 */
│ │ │ │ │ -106 0x00038d7eu, /* 20 */
│ │ │ │ │ -107 0xa4c68000u, /* 21 */
│ │ │ │ │ -108 0x002386f2u, /* 22 */
│ │ │ │ │ -109 0x6fc10000u, /* 23 */
│ │ │ │ │ -110 0x01634578u, /* 24 */
│ │ │ │ │ -111 0x5d8a0000u, /* 25 */
│ │ │ │ │ -112 0x0de0b6b3u, /* 26 */
│ │ │ │ │ -113 0xa7640000u, /* 27 */
│ │ │ │ │ -114 0x8ac72304u, /* 28 */
│ │ │ │ │ -115 0x89e80000u, /* 29 */
│ │ │ │ │ -116 0x00000005u, /* 30 */
│ │ │ │ │ -117 0x6bc75e2du, /* 31 */
│ │ │ │ │ -118 0x63100000u, /* 32 */
│ │ │ │ │ -119 0x00000036u, /* 33 */
│ │ │ │ │ -120 0x35c9adc5u, /* 34 */
│ │ │ │ │ -121 0xdea00000u, /* 35 */
│ │ │ │ │ -122 0x0000021eu, /* 36 */
│ │ │ │ │ -123 0x19e0c9bau, /* 37 */
│ │ │ │ │ -124 0xb2400000u, /* 38 */
│ │ │ │ │ -125 0x0000152du, /* 39 */
│ │ │ │ │ -126 0x02c7e14au, /* 40 */
│ │ │ │ │ -127 0xf6800000u, /* 41 */
│ │ │ │ │ -128 0x0000d3c2u, /* 42 */
│ │ │ │ │ -129 0x1bceccedu, /* 43 */
│ │ │ │ │ -130 0xa1000000u, /* 44 */
│ │ │ │ │ -131 0x00084595u, /* 45 */
│ │ │ │ │ -132 0x16140148u, /* 46 */
│ │ │ │ │ -133 0x4a000000u, /* 47 */
│ │ │ │ │ -134 0x0052b7d2u, /* 48 */
│ │ │ │ │ -135 0xdcc80cd2u, /* 49 */
│ │ │ │ │ -136 0xe4000000u, /* 50 */
│ │ │ │ │ -137 0x033b2e3cu, /* 51 */
│ │ │ │ │ -138 0x9fd0803cu, /* 52 */
│ │ │ │ │ -139 0xe8000000u, /* 53 */
│ │ │ │ │ -140 0x204fce5eu, /* 54 */
│ │ │ │ │ -141 0x3e250261u, /* 55 */
│ │ │ │ │ -142 0x10000000u, /* 56 */
│ │ │ │ │ -143 0x00000001u, /* 57 */
│ │ │ │ │ -144 0x431e0faeu, /* 58 */
│ │ │ │ │ -145 0x6d7217cau, /* 59 */
│ │ │ │ │ -146 0xa0000000u, /* 60 */
│ │ │ │ │ -147 0x0000000cu, /* 61 */
│ │ │ │ │ -148 0x9f2c9cd0u, /* 62 */
│ │ │ │ │ -149 0x4674edeau, /* 63 */
│ │ │ │ │ -150 0x40000000u, /* 64 */
│ │ │ │ │ -151 0x0000007eu, /* 65 */
│ │ │ │ │ -152 0x37be2022u, /* 66 */
│ │ │ │ │ -153 0xc0914b26u, /* 67 */
│ │ │ │ │ -154 0x80000000u, /* 68 */
│ │ │ │ │ -155 0x000004eeu, /* 69 */
│ │ │ │ │ -156 0x2d6d415bu, /* 70 */
│ │ │ │ │ -157 0x85acef81u, /* 71 */
│ │ │ │ │ -158 0x0000314du, /* 72 */
│ │ │ │ │ -159 0xc6448d93u, /* 73 */
│ │ │ │ │ -160 0x38c15b0au, /* 74 */
│ │ │ │ │ -161 0x0001ed09u, /* 75 */
│ │ │ │ │ -162 0xbead87c0u, /* 76 */
│ │ │ │ │ -163 0x378d8e64u, /* 77 */
│ │ │ │ │ -164 0x00134261u, /* 78 */
│ │ │ │ │ -165 0x72c74d82u, /* 79 */
│ │ │ │ │ -166 0x2b878fe8u, /* 80 */
│ │ │ │ │ -167 0x00c097ceu, /* 81 */
│ │ │ │ │ -168 0x7bc90715u, /* 82 */
│ │ │ │ │ -169 0xb34b9f10u, /* 83 */
│ │ │ │ │ -170 0x0785ee10u, /* 84 */
│ │ │ │ │ -171 0xd5da46d9u, /* 85 */
│ │ │ │ │ -172 0x00f436a0u, /* 86 */
│ │ │ │ │ -173 0x4b3b4ca8u, /* 87 */
│ │ │ │ │ -174 0x5a86c47au, /* 88 */
│ │ │ │ │ -175 0x098a2240u, /* 89 */
│ │ │ │ │ -176 0x00000002u, /* 90 */
│ │ │ │ │ -177 0xf050fe93u, /* 91 */
│ │ │ │ │ -178 0x8943acc4u, /* 92 */
│ │ │ │ │ -179 0x5f655680u, /* 93 */
│ │ │ │ │ -180 0x0000001du, /* 94 */
│ │ │ │ │ -181 0x6329f1c3u, /* 95 */
│ │ │ │ │ -182 0x5ca4bfabu, /* 96 */
│ │ │ │ │ -183 0xb9f56100u, /* 97 */
│ │ │ │ │ -184 0x00000125u, /* 98 */
│ │ │ │ │ -185 0xdfa371a1u, /* 99 */
│ │ │ │ │ -186 0x9e6f7cb5u, /* 100 */
│ │ │ │ │ -187 0x4395ca00u, /* 101 */
│ │ │ │ │ -188 0x00000b7au, /* 102 */
│ │ │ │ │ -189 0xbc627050u, /* 103 */
│ │ │ │ │ -190 0x305adf14u, /* 104 */
│ │ │ │ │ -191 0xa3d9e400u, /* 105 */
│ │ │ │ │ -192 0x000072cbu, /* 106 */
│ │ │ │ │ -193 0x5bd86321u, /* 107 */
│ │ │ │ │ -194 0xe38cb6ceu, /* 108 */
│ │ │ │ │ -195 0x6682e800u, /* 109 */
│ │ │ │ │ -196 0x00047bf1u, /* 110 */
│ │ │ │ │ -197 0x9673df52u, /* 111 */
│ │ │ │ │ -198 0xe37f2410u, /* 112 */
│ │ │ │ │ -199 0x011d1000u, /* 113 */
│ │ │ │ │ -200 0x002cd76fu, /* 114 */
│ │ │ │ │ -201 0xe086b93cu, /* 115 */
│ │ │ │ │ -202 0xe2f768a0u, /* 116 */
│ │ │ │ │ -203 0x0b22a000u, /* 117 */
│ │ │ │ │ -204 0x01c06a5eu, /* 118 */
│ │ │ │ │ -205 0xc5433c60u, /* 119 */
│ │ │ │ │ -206 0xddaa1640u, /* 120 */
│ │ │ │ │ -207 0x6f5a4000u, /* 121 */
│ │ │ │ │ -208 0x118427b3u, /* 122 */
│ │ │ │ │ -209 0xb4a05bc8u, /* 123 */
│ │ │ │ │ -210 0xa8a4de84u, /* 124 */
│ │ │ │ │ -211 0x59868000u, /* 125 */
│ │ │ │ │ -212 0xaf298d05u, /* 126 */
│ │ │ │ │ -213 0x0e4395d6u, /* 127 */
│ │ │ │ │ -214 0x9670b12bu, /* 128 */
│ │ │ │ │ -215 0x7f410000u, /* 129 */
│ │ │ │ │ -216 0x00000006u, /* 130 */
│ │ │ │ │ -217 0xd79f8232u, /* 131 */
│ │ │ │ │ -218 0x8ea3da61u, /* 132 */
│ │ │ │ │ -219 0xe066ebb2u, /* 133 */
│ │ │ │ │ -220 0xf88a0000u, /* 134 */
│ │ │ │ │ -221 0x00000044u, /* 135 */
│ │ │ │ │ -222 0x6c3b15f9u, /* 136 */
│ │ │ │ │ -223 0x926687d2u, /* 137 */
│ │ │ │ │ -224 0xc40534fdu, /* 138 */
│ │ │ │ │ -225 0xb5640000u, /* 139 */
│ │ │ │ │ -226 0x000002acu, /* 140 */
│ │ │ │ │ -227 0x3a4edbbfu, /* 141 */
│ │ │ │ │ -228 0xb8014e3bu, /* 142 */
│ │ │ │ │ -229 0xa83411e9u, /* 143 */
│ │ │ │ │ -230 0x15e80000u, /* 144 */
│ │ │ │ │ -231 0x00001abau, /* 145 */
│ │ │ │ │ -232 0x4714957du, /* 146 */
│ │ │ │ │ -233 0x300d0e54u, /* 147 */
│ │ │ │ │ -234 0x9208b31au, /* 148 */
│ │ │ │ │ -235 0xdb100000u, /* 149 */
│ │ │ │ │ -236 0x00010b46u, /* 150 */
│ │ │ │ │ -237 0xc6cdd6e3u, /* 151 */
│ │ │ │ │ -238 0xe0828f4du, /* 152 */
│ │ │ │ │ -239 0xb456ff0cu, /* 153 */
│ │ │ │ │ -240 0x8ea00000u, /* 154 */
│ │ │ │ │ -241 0x000a70c3u, /* 155 */
│ │ │ │ │ -242 0xc40a64e6u, /* 156 */
│ │ │ │ │ -243 0xc5199909u, /* 157 */
│ │ │ │ │ -244 0x0b65f67du, /* 158 */
│ │ │ │ │ -245 0x92400000u, /* 159 */
│ │ │ │ │ -246 0x006867a5u, /* 160 */
│ │ │ │ │ -247 0xa867f103u, /* 161 */
│ │ │ │ │ -248 0xb2fffa5au, /* 162 */
│ │ │ │ │ -249 0x71fba0e7u, /* 163 */
│ │ │ │ │ -250 0xb6800000u, /* 164 */
│ │ │ │ │ -251 0x04140c78u, /* 165 */
│ │ │ │ │ -252 0x940f6a24u, /* 166 */
│ │ │ │ │ -253 0xfdffc788u, /* 167 */
│ │ │ │ │ -254 0x73d4490du, /* 168 */
│ │ │ │ │ -255 0x21000000u, /* 169 */
│ │ │ │ │ -256 0x28c87cb5u, /* 170 */
│ │ │ │ │ -257 0xc89a2571u, /* 171 */
│ │ │ │ │ -258 0xebfdcb54u, /* 172 */
│ │ │ │ │ -259 0x864ada83u, /* 173 */
│ │ │ │ │ -260 0x4a000000u, /* 174 */
│ │ │ │ │ -261 0x00000001u, /* 175 */
│ │ │ │ │ -262 0x97d4df19u, /* 176 */
│ │ │ │ │ -263 0xd6057673u, /* 177 */
│ │ │ │ │ -264 0x37e9f14du, /* 178 */
│ │ │ │ │ -265 0x3eec8920u, /* 179 */
│ │ │ │ │ -266 0xe4000000u, /* 180 */
│ │ │ │ │ -267 0x0000000fu, /* 181 */
│ │ │ │ │ -268 0xee50b702u, /* 182 */
│ │ │ │ │ -269 0x5c36a080u, /* 183 */
│ │ │ │ │ -270 0x2f236d04u, /* 184 */
│ │ │ │ │ -271 0x753d5b48u, /* 185 */
│ │ │ │ │ -272 0xe8000000u, /* 186 */
│ │ │ │ │ -273 0x0000009fu, /* 187 */
│ │ │ │ │ -274 0x4f272617u, /* 188 */
│ │ │ │ │ -275 0x9a224501u, /* 189 */
│ │ │ │ │ -276 0xd762422cu, /* 190 */
│ │ │ │ │ -277 0x946590d9u, /* 191 */
│ │ │ │ │ -278 0x10000000u, /* 192 */
│ │ │ │ │ -279 0x00000639u, /* 193 */
│ │ │ │ │ -280 0x17877cecu, /* 194 */
│ │ │ │ │ -281 0x0556b212u, /* 195 */
│ │ │ │ │ -282 0x69d695bdu, /* 196 */
│ │ │ │ │ -283 0xcbf7a87au, /* 197 */
│ │ │ │ │ -284 0xa0000000u, /* 198 */
│ │ │ │ │ -285 0x00003e3au, /* 199 */
│ │ │ │ │ -286 0xeb4ae138u, /* 200 */
│ │ │ │ │ -287 0x3562f4b8u, /* 201 */
│ │ │ │ │ -288 0x2261d969u, /* 202 */
│ │ │ │ │ -289 0xf7ac94cau, /* 203 */
│ │ │ │ │ -290 0x40000000u, /* 204 */
│ │ │ │ │ -291 0x00026e4du, /* 205 */
│ │ │ │ │ -292 0x30eccc32u, /* 206 */
│ │ │ │ │ -293 0x15dd8f31u, /* 207 */
│ │ │ │ │ -294 0x57d27e23u, /* 208 */
│ │ │ │ │ -295 0xacbdcfe6u, /* 209 */
│ │ │ │ │ -296 0x80000000u, /* 210 */
│ │ │ │ │ -297 0x00184f03u, /* 211 */
│ │ │ │ │ -298 0xe93ff9f4u, /* 212 */
│ │ │ │ │ -299 0xdaa797edu, /* 213 */
│ │ │ │ │ -300 0x6e38ed64u, /* 214 */
│ │ │ │ │ -301 0xbf6a1f01u, /* 215 */
│ │ │ │ │ -302 0x00f31627u, /* 216 */
│ │ │ │ │ -303 0x1c7fc390u, /* 217 */
│ │ │ │ │ -304 0x8a8bef46u, /* 218 */
│ │ │ │ │ -305 0x4e3945efu, /* 219 */
│ │ │ │ │ -306 0x7a25360au, /* 220 */
│ │ │ │ │ -307 0x097edd87u, /* 221 */
│ │ │ │ │ -308 0x1cfda3a5u, /* 222 */
│ │ │ │ │ -309 0x697758bfu, /* 223 */
│ │ │ │ │ -310 0x0e3cbb5au, /* 224 */
│ │ │ │ │ -311 0xc5741c64u, /* 225 */
│ │ │ │ │ -312 0x5ef4a747u, /* 226 */
│ │ │ │ │ -313 0x21e86476u, /* 227 */
│ │ │ │ │ -314 0x1ea97776u, /* 228 */
│ │ │ │ │ -315 0x8e5f518bu, /* 229 */
│ │ │ │ │ -316 0xb6891be8u, /* 230 */
│ │ │ │ │ -317 0x00000003u, /* 231 */
│ │ │ │ │ -318 0xb58e88c7u, /* 232 */
│ │ │ │ │ -319 0x5313ec9du, /* 233 */
│ │ │ │ │ -320 0x329eaaa1u, /* 234 */
│ │ │ │ │ -321 0x8fb92f75u, /* 235 */
│ │ │ │ │ -322 0x215b1710u, /* 236 */
│ │ │ │ │ -323 0x00000025u, /* 237 */
│ │ │ │ │ -324 0x179157c9u, /* 238 */
│ │ │ │ │ -325 0x3ec73e23u, /* 239 */
│ │ │ │ │ -326 0xfa32aa4fu, /* 240 */
│ │ │ │ │ -327 0x9d3bda93u, /* 241 */
│ │ │ │ │ -328 0x4d8ee6a0u, /* 242 */
│ │ │ │ │ -329 0x00000172u, /* 243 */
│ │ │ │ │ -330 0xebad6ddcu, /* 244 */
│ │ │ │ │ -331 0x73c86d67u, /* 245 */
│ │ │ │ │ -332 0xc5faa71cu, /* 246 */
│ │ │ │ │ -333 0x245689c1u, /* 247 */
│ │ │ │ │ -334 0x07950240u, /* 248 */
│ │ │ │ │ -335 0x00000e7du, /* 249 */
│ │ │ │ │ -336 0x34c64a9cu, /* 250 */
│ │ │ │ │ -337 0x85d4460du, /* 251 */
│ │ │ │ │ -338 0xbbca8719u, /* 252 */
│ │ │ │ │ -339 0x6b61618au, /* 253 */
│ │ │ │ │ -340 0x4bd21680u, /* 254 */
│ │ │ │ │ -341 0x000090e4u, /* 255 */
│ │ │ │ │ -342 0x0fbeea1du, /* 256 */
│ │ │ │ │ -343 0x3a4abc89u, /* 257 */
│ │ │ │ │ -344 0x55e946feu, /* 258 */
│ │ │ │ │ -345 0x31cdcf66u, /* 259 */
│ │ │ │ │ -346 0xf634e100u, /* 260 */
│ │ │ │ │ -347 0x0005a8e8u, /* 261 */
│ │ │ │ │ -348 0x9d752524u, /* 262 */
│ │ │ │ │ -349 0x46eb5d5du, /* 263 */
│ │ │ │ │ -350 0x5b1cc5edu, /* 264 */
│ │ │ │ │ -351 0xf20a1a05u, /* 265 */
│ │ │ │ │ -352 0x9e10ca00u, /* 266 */
│ │ │ │ │ -353 0x00389916u, /* 267 */
│ │ │ │ │ -354 0x2693736au, /* 268 */
│ │ │ │ │ -355 0xc531a5a5u, /* 269 */
│ │ │ │ │ -356 0x8f1fbb4bu, /* 270 */
│ │ │ │ │ -357 0x74650438u, /* 271 */
│ │ │ │ │ -358 0x2ca7e400u, /* 272 */
│ │ │ │ │ -359 0x0235faddu, /* 273 */
│ │ │ │ │ -360 0x81c2822bu, /* 274 */
│ │ │ │ │ -361 0xb3f07877u, /* 275 */
│ │ │ │ │ -362 0x973d50f2u, /* 276 */
│ │ │ │ │ -363 0x8bf22a31u, /* 277 */
│ │ │ │ │ -364 0xbe8ee800u, /* 278 */
│ │ │ │ │ -365 0x161bcca7u, /* 279 */
│ │ │ │ │ -366 0x119915b5u, /* 280 */
│ │ │ │ │ -367 0x0764b4abu, /* 281 */
│ │ │ │ │ -368 0xe8652979u, /* 282 */
│ │ │ │ │ -369 0x7775a5f1u, /* 283 */
│ │ │ │ │ -370 0x71951000u, /* 284 */
│ │ │ │ │ -371 0xdd15fe86u, /* 285 */
│ │ │ │ │ -372 0xaffad912u, /* 286 */
│ │ │ │ │ -373 0x49ef0eb7u, /* 287 */
│ │ │ │ │ -374 0x13f39ebeu, /* 288 */
│ │ │ │ │ -375 0xaa987b6eu, /* 289 */
│ │ │ │ │ -376 0x6fd2a000u, /* 290 */
│ │ │ │ │ -377};
│ │ │ │ │ + * _d_b_l_i_b
│ │ │ │ │ +buffering.h
│ │ │ │ │ +_1typedef struct _d_b_l_i_b___b_u_f_f_e_r___r_o_w {
│ │ │ │ │ +_3 _T_D_S_R_E_S_U_L_T_I_N_F_O *_r_e_s_i_n_f_o;
│ │ │ │ │ +_5 unsigned char *_r_o_w___d_a_t_a;
│ │ │ │ │ +_7 DBINT _r_o_w;
│ │ │ │ │ +_9 TDS_INT *_s_i_z_e_s;
│ │ │ │ │ +10} _D_B_L_I_B___B_U_F_F_E_R___R_O_W;
│ │ │ │ │ +11
│ │ │ │ │ +12static void buffer_struct_print(const _D_B_P_R_O_C___R_O_W_B_U_F *buf);
│ │ │ │ │ +13static RETCODE buffer_save_row(_D_B_P_R_O_C_E_S_S *dbproc);
│ │ │ │ │ +14static _D_B_L_I_B___B_U_F_F_E_R___R_O_W* buffer_row_address(const _D_B_P_R_O_C___R_O_W_B_U_F * buf, int
│ │ │ │ │ +idx);
│ │ │ │ │ +15
│ │ │ │ │ +16#if ENABLE_EXTRA_CHECKS
│ │ │ │ │ +17static void buffer_check_row_empty(_D_B_L_I_B___B_U_F_F_E_R___R_O_W *row)
│ │ │ │ │ +18{
│ │ │ │ │ +19 assert(row->_r_e_s_i_n_f_o == NULL);
│ │ │ │ │ +20 assert(row->_r_o_w___d_a_t_a == NULL);
│ │ │ │ │ +21 assert(row->_s_i_z_e_s == NULL);
│ │ │ │ │ +22 assert(row->_r_o_w == 0);
│ │ │ │ │ +23}
│ │ │ │ │ +24
│ │ │ │ │ +25static void buffer_check(const _D_B_P_R_O_C___R_O_W_B_U_F *buf)
│ │ │ │ │ +26{
│ │ │ │ │ +27 int i;
│ │ │ │ │ +28
│ │ │ │ │ +29 /* no buffering */
│ │ │ │ │ +30 if (buf->capacity == 0 || buf->capacity == 1) {
│ │ │ │ │ +31 assert(buf->head == 0);
│ │ │ │ │ +32 assert(buf->tail == 0 || buf->tail == 1);
│ │ │ │ │ +33 assert(buf->capacity == 1 || buf->rows == NULL);
│ │ │ │ │ +34 return;
│ │ │ │ │ +35 }
│ │ │ │ │ +36
│ │ │ │ │ +37 assert(buf->capacity > 0);
│ │ │ │ │ +38 assert(buf->head >= 0);
│ │ │ │ │ +39 assert(buf->tail >= 0);
│ │ │ │ │ +40 assert(buf->head < buf->capacity);
│ │ │ │ │ +41 assert(buf->tail <= buf->capacity);
│ │ │ │ │ +42
│ │ │ │ │ +43 /* check empty */
│ │ │ │ │ +44 if (buf->tail == buf->capacity) {
│ │ │ │ │ +45 assert(buf->head == 0);
│ │ │ │ │ +46 for (i = 0; buf->rows && i < buf->capacity; ++i)
│ │ │ │ │ +47 buffer_check_row_empty(&buf->rows[i]);
│ │ │ │ │ +48 return;
│ │ │ │ │ +49 }
│ │ │ │ │ +50
│ │ │ │ │ +51 if (buf->rows == NULL)
│ │ │ │ │ +52 return;
│ │ │ │ │ +53
│ │ │ │ │ +54 /* check filled part */
│ │ │ │ │ +55 i = buf->tail;
│ │ │ │ │ +56 do {
│ │ │ │ │ +57 assert(i >= 0 && i < buf->capacity);
│ │ │ │ │ +58 assert(buf->rows[i]._r_e_s_i_n_f_o != NULL);
│ │ │ │ │ +59 assert(buf->rows[i]._r_o_w > 0);
│ │ │ │ │ +60 assert(buf->rows[i]._r_o_w <= buf->received);
│ │ │ │ │ +61 ++i;
│ │ │ │ │ +62 if (i == buf->capacity)
│ │ │ │ │ +63 i = 0;
│ │ │ │ │ +64 } while (i != buf->head);
│ │ │ │ │ +65
│ │ │ │ │ +66 /* check empty part */
│ │ │ │ │ +67 if (buf->head != buf->tail) {
│ │ │ │ │ +68 i = buf->head;
│ │ │ │ │ +69 do {
│ │ │ │ │ +70 assert(i >= 0 && i < buf->capacity);
│ │ │ │ │ +71 buffer_check_row_empty(&buf->rows[i]);
│ │ │ │ │ +72 ++i;
│ │ │ │ │ +73 if (i == buf->capacity)
│ │ │ │ │ +74 i = 0;
│ │ │ │ │ +75 } while (i != buf->tail);
│ │ │ │ │ +76 }
│ │ │ │ │ +77}
│ │ │ │ │ +78#define BUFFER_CHECK(buf) buffer_check(buf)
│ │ │ │ │ +79#else
│ │ │ │ │ +80#define BUFFER_CHECK(buf) do {} while(0)
│ │ │ │ │ +81#endif
│ │ │ │ │ +111static int
│ │ │ │ │ +112buffer_count(const _D_B_P_R_O_C___R_O_W_B_U_F *buf)
│ │ │ │ │ +113{
│ │ │ │ │ +114 BUFFER_CHECK(buf);
│ │ │ │ │ +115 return (buf->head > buf->tail) ?
│ │ │ │ │ +116 buf->head - buf->tail : /* |...TddddH....| */
│ │ │ │ │ +117 buf->capacity - (buf->tail - buf->head); /* |ddddH....Tddd| */
│ │ │ │ │ +118}
│ │ │ │ │ +119
│ │ │ │ │ +123static int
│ │ │ │ │ +124buffer_is_full(const _D_B_P_R_O_C___R_O_W_B_U_F *buf)
│ │ │ │ │ +125{
│ │ │ │ │ +126 BUFFER_CHECK(buf);
│ │ │ │ │ +127 return buf->capacity == buffer_count(buf) && buf->capacity > 1;
│ │ │ │ │ +128}
│ │ │ │ │ +129
│ │ │ │ │ +130#ifndef NDEBUG
│ │ │ │ │ +131static int
│ │ │ │ │ +132buffer_index_valid(const _D_B_P_R_O_C___R_O_W_B_U_F *buf, int idx)
│ │ │ │ │ +133{
│ │ │ │ │ +134 BUFFER_CHECK(buf);
│ │ │ │ │ +135 if (buf->tail <= buf->head)
│ │ │ │ │ +136 if (buf->head <= idx && idx <= buf->tail)
│ │ │ │ │ +137 return 1;
│ │ │ │ │ +138
│ │ │ │ │ +139 if (0 <= idx && idx <= buf->head)
│ │ │ │ │ +140 return 1;
│ │ │ │ │ +141
│ │ │ │ │ +142 if (buf->tail <= idx && idx < buf->capacity)
│ │ │ │ │ +143 return 1;
│ │ │ │ │ +144#if 0
│ │ │ │ │ +145 printf("buffer_index_valid: idx = %d\n", idx);
│ │ │ │ │ +146 buffer_struct_print(buf);
│ │ │ │ │ +147#endif
│ │ │ │ │ +148 return 0;
│ │ │ │ │ +149}
│ │ │ │ │ +150#endif
│ │ │ │ │ +151
│ │ │ │ │ +152static void
│ │ │ │ │ +153buffer_free_row(_D_B_L_I_B___B_U_F_F_E_R___R_O_W *row)
│ │ │ │ │ +154{
│ │ │ │ │ +155 if (row->_s_i_z_e_s)
│ │ │ │ │ +156 TDS_ZERO_FREE(row->_s_i_z_e_s);
│ │ │ │ │ +157 if (row->_r_o_w___d_a_t_a) {
│ │ │ │ │ +158 tds_free_row(row->_r_e_s_i_n_f_o, row->_r_o_w___d_a_t_a);
│ │ │ │ │ +159 row->_r_o_w___d_a_t_a = NULL;
│ │ │ │ │ +160 }
│ │ │ │ │ +161 tds_free_results(row->_r_e_s_i_n_f_o);
│ │ │ │ │ +162 row->_r_e_s_i_n_f_o = NULL;
│ │ │ │ │ +163 row->_r_o_w = 0;
│ │ │ │ │ +164}
│ │ │ │ │ +165
│ │ │ │ │ +166/*
│ │ │ │ │ +167 * Buffer is freed at slightly odd points, whenever
│ │ │ │ │ +168 * capacity changes:
│ │ │ │ │ +169 *
│ │ │ │ │ +170 * 1. When setting capacity, to release prior buffer.
│ │ │ │ │ +171 * 2. By dbresults. When called the second time, it has to
│ │ │ │ │ +172 * release prior storage because the new resultset will have
│ │ │ │ │ +173 * a different width.
│ │ │ │ │ +174 * 3. By dbclose(), else open/close/open would leak.
│ │ │ │ │ +175 */
│ │ │ │ │ +176static void
│ │ │ │ │ +177buffer_free(_D_B_P_R_O_C___R_O_W_B_U_F *buf)
│ │ │ │ │ +178{
│ │ │ │ │ +179 BUFFER_CHECK(buf);
│ │ │ │ │ +180 if (buf->rows != NULL) {
│ │ │ │ │ +181 int i;
│ │ │ │ │ +182 for (i = 0; i < buf->capacity; ++i)
│ │ │ │ │ +183 buffer_free_row(&buf->rows[i]);
│ │ │ │ │ +184 TDS_ZERO_FREE(buf->rows);
│ │ │ │ │ +185 }
│ │ │ │ │ +186 BUFFER_CHECK(buf);
│ │ │ │ │ +187}
│ │ │ │ │ +188
│ │ │ │ │ +189/*
│ │ │ │ │ +190 * When no rows are currently buffered (and the buffer is allocated)
│ │ │ │ │ +191 * set the indices to their initial positions.
│ │ │ │ │ +192 */
│ │ │ │ │ +193static void
│ │ │ │ │ +194buffer_reset(_D_B_P_R_O_C___R_O_W_B_U_F *buf)
│ │ │ │ │ +195{
│ │ │ │ │ +196 buf->head = 0;
│ │ │ │ │ +197 buf->current = buf->tail = buf->capacity;
│ │ │ │ │ +198 BUFFER_CHECK(buf);
│ │ │ │ │ +199}
│ │ │ │ │ +200
│ │ │ │ │ +201static int
│ │ │ │ │ +202buffer_idx_increment(const _D_B_P_R_O_C___R_O_W_B_U_F *buf, int idx)
│ │ │ │ │ +203{
│ │ │ │ │ +204 if (++idx >= buf->capacity) {
│ │ │ │ │ +205 idx = 0;
│ │ │ │ │ +206 }
│ │ │ │ │ +207 return idx;
│ │ │ │ │ +208}
│ │ │ │ │ +209
│ │ │ │ │ +214static _D_B_L_I_B___B_U_F_F_E_R___R_O_W*
│ │ │ │ │ +215buffer_row_address(const _D_B_P_R_O_C___R_O_W_B_U_F * buf, int idx)
│ │ │ │ │ +216{
│ │ │ │ │ +217 BUFFER_CHECK(buf);
│ │ │ │ │ +218 if (idx < 0 || idx >= buf->capacity) {
│ │ │ │ │ +219 printf("idx is %d:\n", idx);
│ │ │ │ │ +220 buffer_struct_print(buf);
│ │ │ │ │ +221 return NULL;
│ │ │ │ │ +222 }
│ │ │ │ │ +223
│ │ │ │ │ +224 return &(buf->rows[idx]);
│ │ │ │ │ +225}
│ │ │ │ │ +226
│ │ │ │ │ +230static DBINT
│ │ │ │ │ +231buffer_idx2row(const _D_B_P_R_O_C___R_O_W_B_U_F *buf, int idx)
│ │ │ │ │ +232{
│ │ │ │ │ +233 BUFFER_CHECK(buf);
│ │ │ │ │ +234 return buffer_row_address(buf, idx)->_r_o_w;
│ │ │ │ │ +235}
│ │ │ │ │ +236
│ │ │ │ │ +240static int
│ │ │ │ │ +241buffer_row2idx(const _D_B_P_R_O_C___R_O_W_B_U_F *buf, int row_number)
│ │ │ │ │ +242{
│ │ │ │ │ +243 int i = buf->tail;
│ │ │ │ │ +244#ifndef NDEBUG
│ │ │ │ │ +245 int ii = 0;
│ │ │ │ │ +246#endif
│ │ │ │ │ +247
│ │ │ │ │ +248 BUFFER_CHECK(buf);
│ │ │ │ │ +249 if (i == buf->capacity) {
│ │ │ │ │ +250 assert (buf->head == 0);
│ │ │ │ │ +251 return -1; /* no rows buffered */
│ │ │ │ │ +252 }
│ │ │ │ │ +253
│ │ │ │ │ +254 /*
│ │ │ │ │ +255 * March through the buffers from tail to head, stop if we find our row.
│ │ │ │ │ +256 * A full queue is indicated by tail == head (which means we can't write).
│ │ │ │ │ +257 */
│ │ │ │ │ +258 do {
│ │ │ │ │ +259 if (buffer_idx2row(buf, i) == row_number)
│ │ │ │ │ +260 return i;
│ │ │ │ │ +261
│ │ │ │ │ +262 assert(ii++ < buf->capacity); /* prevent infinite loop */
│ │ │ │ │ +263
│ │ │ │ │ +264 i = buffer_idx_increment(buf, i);
│ │ │ │ │ +265 } while (i != buf->head);
│ │ │ │ │ +266
│ │ │ │ │ +267 return -1;
│ │ │ │ │ +268}
│ │ │ │ │ +269
│ │ │ │ │ +274static void
│ │ │ │ │ +275buffer_delete_rows(_D_B_P_R_O_C___R_O_W_B_U_F * buf, int count)
│ │ │ │ │ +276{
│ │ │ │ │ +277 int i;
│ │ │ │ │ +278
│ │ │ │ │ +279 BUFFER_CHECK(buf);
│ │ │ │ │ +280 if (count < 0 || count > buffer_count(buf)) {
│ │ │ │ │ +281 count = buffer_count(buf);
│ │ │ │ │ +282 }
│ │ │ │ │ +283
│ │ │ │ │ +284 for (i=0; i < count; i++) {
│ │ │ │ │ +285 if (buf->tail < buf->capacity)
│ │ │ │ │ +286 buffer_free_row(&buf->rows[buf->tail]);
│ │ │ │ │ +287 buf->tail = buffer_idx_increment(buf, buf->tail);
│ │ │ │ │ +288 /*
│ │ │ │ │ +289 * If deleting rows from the buffer catches the tail to the head,
│ │ │ │ │ +290 * return to the initial position. Otherwise, it will look full.
│ │ │ │ │ +291 */
│ │ │ │ │ +292 if (buf->tail == buf->head) {
│ │ │ │ │ +293 buffer_reset(buf);
│ │ │ │ │ +294 break;
│ │ │ │ │ +295 }
│ │ │ │ │ +296 }
│ │ │ │ │ +297#if 0
│ │ │ │ │ +298 buffer_struct_print(buf);
│ │ │ │ │ +299#endif
│ │ │ │ │ +300 BUFFER_CHECK(buf);
│ │ │ │ │ +301}
│ │ │ │ │ +302
│ │ │ │ │ +306static void
│ │ │ │ │ +307buffer_transfer_bound_data(_D_B_P_R_O_C___R_O_W_B_U_F *buf, TDS_INT res_type, TDS_INT
│ │ │ │ │ +compute_id, _D_B_P_R_O_C_E_S_S * dbproc, int idx)
│ │ │ │ │ +308{
│ │ │ │ │ +309 int i;
│ │ │ │ │ +310 BYTE *src;
│ │ │ │ │ +311 const _D_B_L_I_B___B_U_F_F_E_R___R_O_W *row;
│ │ │ │ │ +312
│ │ │ │ │ +313 tdsdump_log(TDS_DBG_FUNC, "buffer_transfer_bound_data(%p %d %d %p %d)\n",
│ │ │ │ │ +buf, res_type, compute_id, dbproc, idx);
│ │ │ │ │ +314 BUFFER_CHECK(buf);
│ │ │ │ │ +315 assert(buffer_index_valid(buf, idx));
│ │ │ │ │ +316
│ │ │ │ │ +317 row = buffer_row_address(buf, idx);
│ │ │ │ │ +318 assert(row->_r_e_s_i_n_f_o);
│ │ │ │ │ +319
│ │ │ │ │ +320 for (i = 0; i < row->_r_e_s_i_n_f_o->num_cols; i++) {
│ │ │ │ │ +321 TDS_SERVER_TYPE srctype;
│ │ │ │ │ +322 DBINT srclen;
│ │ │ │ │ +323 _T_D_S_C_O_L_U_M_N *curcol = row->_r_e_s_i_n_f_o->columns[i];
│ │ │ │ │ +324
│ │ │ │ │ +325 if (row->_s_i_z_e_s)
│ │ │ │ │ +326 curcol->_c_o_l_u_m_n___c_u_r___s_i_z_e = row->_s_i_z_e_s[i];
│ │ │ │ │ +327
│ │ │ │ │ +328 srclen = curcol->_c_o_l_u_m_n___c_u_r___s_i_z_e;
│ │ │ │ │ +329
│ │ │ │ │ +330 if (curcol->column_nullbind) {
│ │ │ │ │ +331 if (srclen < 0) {
│ │ │ │ │ +332 *(DBINT *)(curcol->column_nullbind) = -1;
│ │ │ │ │ +333 } else {
│ │ │ │ │ +334 *(DBINT *)(curcol->column_nullbind) = 0;
│ │ │ │ │ +335 }
│ │ │ │ │ +336 }
│ │ │ │ │ +337 if (!curcol->column_varaddr)
│ │ │ │ │ +338 continue;
│ │ │ │ │ +339
│ │ │ │ │ +340 if (srclen <= 0) {
│ │ │ │ │ +341 if (srclen == 0 || !curcol->column_nullbind)
│ │ │ │ │ +342 _d_b_g_e_t_n_u_l_l(dbproc, curcol->column_bindtype, curcol->column_bindlen,
│ │ │ │ │ +343 (BYTE *) curcol->column_varaddr);
│ │ │ │ │ +344 continue;
│ │ │ │ │ +345 }
│ │ │ │ │ +346
│ │ │ │ │ +347 srctype = tds_get_conversion_type(curcol->_c_o_l_u_m_n___t_y_p_e, curcol-
│ │ │ │ │ +>_c_o_l_u_m_n___s_i_z_e);
│ │ │ │ │ +348
│ │ │ │ │ +349 if (row->_r_o_w___d_a_t_a)
│ │ │ │ │ +350 src = &row->_r_o_w___d_a_t_a[curcol->column_data - row->_r_e_s_i_n_f_o->current_row];
│ │ │ │ │ +351 else
│ │ │ │ │ +352 src = curcol->column_data;
│ │ │ │ │ +353 if (is_blob_col(curcol))
│ │ │ │ │ +354 src = (BYTE *) ((_T_D_S_B_L_O_B *) src)->textvalue;
│ │ │ │ │ +355
│ │ │ │ │ +356 copy_data_to_host_var(dbproc, srctype, src, srclen,
│ │ │ │ │ +357 (BYTE *) curcol->column_varaddr, curcol->column_bindlen,
│ │ │ │ │ +358 curcol->column_bindtype, (DBINT*) curcol->column_nullbind);
│ │ │ │ │ +359 }
│ │ │ │ │ +360
│ │ │ │ │ +361 /*
│ │ │ │ │ +362 * This function always bumps current. Usually, it's called
│ │ │ │ │ +363 * by dbnextrow(), so bumping current is a pretty obvious choice.
│ │ │ │ │ +364 * It can also be called by dbgetrow(), but that function also
│ │ │ │ │ +365 * causes the bump. If you call dbgetrow() for row N, a subsequent
│ │ │ │ │ +366 * call to dbnextrow() yields N+1.
│ │ │ │ │ +367 */
│ │ │ │ │ +368 buf->current = buffer_idx_increment(buf, buf->current);
│ │ │ │ │ +369
│ │ │ │ │ +370} /* end buffer_transfer_bound_data() */
│ │ │ │ │ +371
│ │ │ │ │ +372static void
│ │ │ │ │ +373buffer_struct_print(const _D_B_P_R_O_C___R_O_W_B_U_F *buf)
│ │ │ │ │ +374{
│ │ │ │ │ +375 assert(buf);
│ │ │ │ │ +376
│ │ │ │ │ +377 printf("\t%d rows in buffer\n", buffer_count(buf));
│ │ │ │ │ +378
│ │ │ │ │ +379 printf("\thead = %d\t", buf->head);
│ │ │ │ │ +380 printf("\ttail = %d\t", buf->tail);
│ │ │ │ │ +381 printf("\tcurrent = %d\n", buf->current);
│ │ │ │ │ +382 printf("\tcapacity = %d\t", buf->capacity);
│ │ │ │ │ +383 printf("\thead row number = %d\n", buf->received);
│ │ │ │ │ +384}
│ │ │ │ │ +385
│ │ │ │ │ +386/* * * Functions called only by public db-lib API take DBPROCESS* * */
│ │ │ │ │ +387
│ │ │ │ │ +404static int
│ │ │ │ │ +405buffer_current_index(const _D_B_P_R_O_C_E_S_S *dbproc)
│ │ │ │ │ +406{
│ │ │ │ │ +407 const _D_B_P_R_O_C___R_O_W_B_U_F *buf = &dbproc->row_buf;
│ │ │ │ │ +408#if 0
│ │ │ │ │ +409 buffer_struct_print(buf);
│ │ │ │ │ +410#endif
│ │ │ │ │ +411 if (buf->capacity <= 1) /* no buffering */
│ │ │ │ │ +412 return -1;
│ │ │ │ │ +413 if (buf->current == buf->head || buf->current == buf->capacity)
│ │ │ │ │ +414 return -1;
│ │ │ │ │ +415
│ │ │ │ │ +416 assert(buf->current >= 0);
│ │ │ │ │ +417 assert(buf->current < buf->capacity);
│ │ │ │ │ +418
│ │ │ │ │ +419 if( buf->tail < buf->head) {
│ │ │ │ │ +420 assert(buf->tail < buf->current);
│ │ │ │ │ +421 assert(buf->current < buf->head);
│ │ │ │ │ +422 } else {
│ │ │ │ │ +423 if (buf->current > buf->head)
│ │ │ │ │ +424 assert(buf->current > buf->tail);
│ │ │ │ │ +425 }
│ │ │ │ │ +426 return buf->current;
│ │ │ │ │ +427}
│ │ │ │ │ +428
│ │ │ │ │ +429/*
│ │ │ │ │ +430 * Normally called by dbsetopt() to prepare for buffering
│ │ │ │ │ +431 * Called with nrows == 0 by dbopen to safely set buf->rows to NULL.
│ │ │ │ │ +432 */
│ │ │ │ │ +433static void
│ │ │ │ │ +434buffer_set_capacity(_D_B_P_R_O_C_E_S_S *dbproc, int nrows)
│ │ │ │ │ +435{
│ │ │ │ │ +436 _D_B_P_R_O_C___R_O_W_B_U_F *buf = &dbproc->row_buf;
│ │ │ │ │ +437
│ │ │ │ │ +438 buffer_free(buf);
│ │ │ │ │ +439
│ │ │ │ │ +440 memset(buf, 0, sizeof(_D_B_P_R_O_C___R_O_W_B_U_F));
│ │ │ │ │ +441
│ │ │ │ │ +442 if (0 == nrows) {
│ │ │ │ │ +443 buf->capacity = 1;
│ │ │ │ │ +444 BUFFER_CHECK(buf);
│ │ │ │ │ +445 return;
│ │ │ │ │ +446 }
│ │ │ │ │ +447
│ │ │ │ │ +448 assert(0 < nrows);
│ │ │ │ │ +449
│ │ │ │ │ +450 buf->capacity = nrows;
│ │ │ │ │ +451 BUFFER_CHECK(buf);
│ │ │ │ │ +452}
│ │ │ │ │ +453
│ │ │ │ │ +454/*
│ │ │ │ │ +455 * Called only by dbresults(); capacity must be >= 1.
│ │ │ │ │ +456 * Sybase's documents say dbresults() cannot return FAIL if the prior calls
│ │ │ │ │ +worked,
│ │ │ │ │ +457 * which is a little strange, because (for FreeTDS, at least), dbresults
│ │ │ │ │ +458 * is when we learn about the result set's width. Without that information,
│ │ │ │ │ +we
│ │ │ │ │ +459 * can't allocate memory for the buffer. But if we *fail* to allocate
│ │ │ │ │ +memory,
│ │ │ │ │ +460 * we're not to communicate it back to the caller?
│ │ │ │ │ +461 */
│ │ │ │ │ +462static void
│ │ │ │ │ +463buffer_alloc(_D_B_P_R_O_C_E_S_S *dbproc)
│ │ │ │ │ +464{
│ │ │ │ │ +465 _D_B_P_R_O_C___R_O_W_B_U_F *buf = &dbproc->row_buf;
│ │ │ │ │ +466
│ │ │ │ │ +467 /* Call this function only after setting capacity. */
│ │ │ │ │ +468
│ │ │ │ │ +469 assert(buf);
│ │ │ │ │ +470 assert(buf->capacity > 0);
│ │ │ │ │ +471 assert(buf->rows == NULL);
│ │ │ │ │ +472
│ │ │ │ │ +473 buf->rows = tds_new0(_D_B_L_I_B___B_U_F_F_E_R___R_O_W, buf->capacity);
│ │ │ │ │ +474
│ │ │ │ │ +475 assert(buf->rows);
│ │ │ │ │ +476
│ │ │ │ │ +477 buffer_reset(buf);
│ │ │ │ │ +478
│ │ │ │ │ +479 buf->received = 0;
│ │ │ │ │ +480}
│ │ │ │ │ +481
│ │ │ │ │ +486static int
│ │ │ │ │ +487buffer_add_row(_D_B_P_R_O_C_E_S_S *dbproc, _T_D_S_R_E_S_U_L_T_I_N_F_O *resinfo)
│ │ │ │ │ +488{
│ │ │ │ │ +489 _D_B_P_R_O_C___R_O_W_B_U_F *buf = &dbproc->row_buf;
│ │ │ │ │ +490 _D_B_L_I_B___B_U_F_F_E_R___R_O_W *row;
│ │ │ │ │ +491 int i;
│ │ │ │ │ +492
│ │ │ │ │ +493 assert(buf->capacity >= 0);
│ │ │ │ │ +494
│ │ │ │ │ +495 if (buffer_is_full(buf))
│ │ │ │ │ +496 return -1;
│ │ │ │ │ +497
│ │ │ │ │ +498 row = buffer_row_address(buf, buf->head);
│ │ │ │ │ +499
│ │ │ │ │ +500 /* bump the row number, write it, and move the data to head */
│ │ │ │ │ +501 if (row->_r_e_s_i_n_f_o) {
│ │ │ │ │ +502 tds_free_row(row->_r_e_s_i_n_f_o, row->_r_o_w___d_a_t_a);
│ │ │ │ │ +503 tds_free_results(row->_r_e_s_i_n_f_o);
│ │ │ │ │ +504 }
│ │ │ │ │ +505 row->_r_o_w = ++buf->received;
│ │ │ │ │ +506 ++resinfo->ref_count;
│ │ │ │ │ +507 row->_r_e_s_i_n_f_o = resinfo;
│ │ │ │ │ +508 row->_r_o_w___d_a_t_a = NULL;
│ │ │ │ │ +509 if (row->_s_i_z_e_s)
│ │ │ │ │ +510 free(row->_s_i_z_e_s);
│ │ │ │ │ +511 row->_s_i_z_e_s = tds_new0(TDS_INT, resinfo->num_cols);
│ │ │ │ │ +512 for (i = 0; i < resinfo->num_cols; ++i)
│ │ │ │ │ +513 row->_s_i_z_e_s[i] = resinfo->columns[i]->_c_o_l_u_m_n___c_u_r___s_i_z_e;
│ │ │ │ │ +514
│ │ │ │ │ +515 /* initial condition is head == 0 and tail == capacity */
│ │ │ │ │ +516 if (buf->tail == buf->capacity) {
│ │ │ │ │ +517 /* bumping this tail will set it to zero */
│ │ │ │ │ +518 assert(buf->head == 0);
│ │ │ │ │ +519 buf->tail = 0;
│ │ │ │ │ +520 }
│ │ │ │ │ +521
│ │ │ │ │ +522 /* update current, bump the head */
│ │ │ │ │ +523 buf->current = buf->head;
│ │ │ │ │ +524 buf->head = buffer_idx_increment(buf, buf->head);
│ │ │ │ │ +525
│ │ │ │ │ +526 return buf->current;
│ │ │ │ │ +527}
│ │ │ │ │ +528
│ │ │ │ │ +532static RETCODE
│ │ │ │ │ +533buffer_save_row(_D_B_P_R_O_C_E_S_S *dbproc)
│ │ │ │ │ +534{
│ │ │ │ │ +535 _D_B_P_R_O_C___R_O_W_B_U_F *buf = &dbproc->row_buf;
│ │ │ │ │ +536 _D_B_L_I_B___B_U_F_F_E_R___R_O_W *row;
│ │ │ │ │ +537 int idx = buf->head - 1;
│ │ │ │ │ +538
│ │ │ │ │ +539 if (buf->capacity <= 1)
│ │ │ │ │ +540 return SUCCEED;
│ │ │ │ │ +541
│ │ │ │ │ +542 if (idx < 0)
│ │ │ │ │ +543 idx = buf->capacity - 1;
│ │ │ │ │ +544 if (idx >= 0 && idx < buf->capacity) {
│ │ │ │ │ +545 row = &buf->rows[idx];
│ │ │ │ │ +546
│ │ │ │ │ +547 if (row->_r_e_s_i_n_f_o && !row->_r_o_w___d_a_t_a) {
│ │ │ │ │ +548 row->_r_o_w___d_a_t_a = row->_r_e_s_i_n_f_o->current_row;
│ │ │ │ │ +549 _t_d_s___a_l_l_o_c___r_o_w(row->_r_e_s_i_n_f_o);
│ │ │ │ │ +550 }
│ │ │ │ │ +551 }
│ │ │ │ │ +552
│ │ │ │ │ +553 return SUCCEED;
│ │ │ │ │ +554}
│ │ │ │ │ +555
│ │ │ │ │ +_d_b_g_e_t_n_u_l_l
│ │ │ │ │ +RETCODE dbgetnull(DBPROCESS *dbproc, int bindtype, int varlen, BYTE *varaddr)
│ │ │ │ │ +DDeeffiinniittiioonn dblib.c:529
│ │ │ │ │ +_t_d_s___a_l_l_o_c___r_o_w
│ │ │ │ │ +TDSRET tds_alloc_row(TDSRESULTINFO *res_info)
│ │ │ │ │ +Allocate space for row store return NULL on out of memory.
│ │ │ │ │ +DDeeffiinniittiioonn mem.c:524
│ │ │ │ │ +_d_b_l_i_b___b_u_f_f_e_r___r_o_w
│ │ │ │ │ +DDeeffiinniittiioonn buffering.h:1
│ │ │ │ │ +_d_b_l_i_b___b_u_f_f_e_r___r_o_w_:_:_r_o_w
│ │ │ │ │ +DBINT row
│ │ │ │ │ +row number
│ │ │ │ │ +DDeeffiinniittiioonn buffering.h:7
│ │ │ │ │ +_d_b_l_i_b___b_u_f_f_e_r___r_o_w_:_:_r_o_w___d_a_t_a
│ │ │ │ │ +unsigned char * row_data
│ │ │ │ │ +row data, NULL for resinfo->current_row
│ │ │ │ │ +DDeeffiinniittiioonn buffering.h:5
│ │ │ │ │ +_d_b_l_i_b___b_u_f_f_e_r___r_o_w_:_:_s_i_z_e_s
│ │ │ │ │ +TDS_INT * sizes
│ │ │ │ │ +save old sizes
│ │ │ │ │ +DDeeffiinniittiioonn buffering.h:9
│ │ │ │ │ +_d_b_l_i_b___b_u_f_f_e_r___r_o_w_:_:_r_e_s_i_n_f_o
│ │ │ │ │ +TDSRESULTINFO * resinfo
│ │ │ │ │ +pointer to result informations
│ │ │ │ │ +DDeeffiinniittiioonn buffering.h:3
│ │ │ │ │ +_D_B_P_R_O_C___R_O_W_B_U_F
│ │ │ │ │ +DDeeffiinniittiioonn dblib.h:52
│ │ │ │ │ +_t_d_s___d_b_l_i_b___d_b_p_r_o_c_e_s_s
│ │ │ │ │ +DDeeffiinniittiioonn dblib.h:123
│ │ │ │ │ +_t_d_s___b_l_o_b
│ │ │ │ │ +Information about blobs (e.g.
│ │ │ │ │ +DDeeffiinniittiioonn tds.h:593
│ │ │ │ │ +_t_d_s___c_o_l_u_m_n
│ │ │ │ │ +Metadata about columns in regular and compute rows.
│ │ │ │ │ +DDeeffiinniittiioonn tds.h:689
│ │ │ │ │ +_t_d_s___c_o_l_u_m_n_:_:_c_o_l_u_m_n___s_i_z_e
│ │ │ │ │ +TDS_INT column_size
│ │ │ │ │ +maximun size of data.
│ │ │ │ │ +DDeeffiinniittiioonn tds.h:694
│ │ │ │ │ +_t_d_s___c_o_l_u_m_n_:_:_c_o_l_u_m_n___t_y_p_e
│ │ │ │ │ +TDS_SERVER_TYPE column_type
│ │ │ │ │ +This type can be different from wire type because conversion (e.g.
│ │ │ │ │ +DDeeffiinniittiioonn tds.h:696
│ │ │ │ │ +_t_d_s___c_o_l_u_m_n_:_:_c_o_l_u_m_n___c_u_r___s_i_z_e
│ │ │ │ │ +TDS_INT column_cur_size
│ │ │ │ │ +size written in variable (ie: char, text, binary).
│ │ │ │ │ +DDeeffiinniittiioonn tds.h:736
│ │ │ │ │ +_t_d_s___r_e_s_u_l_t___i_n_f_o
│ │ │ │ │ +Hold information for any results.
│ │ │ │ │ +DDeeffiinniittiioonn tds.h:769
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/freetds-doc/reference/a00239_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -