/*			 * All three of these result types are fetchable.			 * Since the result model for rpcs and rows have			 * been unified in the New Client-Library, we			 * will use the same routine to display them			 */			/*			 * Find out how many columns there are in this result set.			 */			ret = ct_res_info(cmd, CS_NUMDATA, &num_cols, CS_UNUSED, NULL);			if (ret != CS_SUCCEED) {				fprintf(stderr, "ct_res_info(CS_NUMDATA) failed");				return 1;			}			/*			 * Make sure we have at least one column			 */			if (num_cols <= 0) {				fprintf(stderr, "ct_res_info(CS_NUMDATA) returned zero columns");				return 1;			}			/*			 * Our program variable, called 'coldata', is an array of			 * EX_COLUMN_DATA structures. Each array element represents			 * one column.  Each array element will re-used for each row.			 * 			 * First, allocate memory for the data element to process.			 */			coldata = (EX_COLUMN_DATA *) malloc(num_cols * sizeof(EX_COLUMN_DATA));			if (coldata == NULL) {				fprintf(stderr, "malloc coldata failed \n");				return 1;			}			outdatafmt = (CS_DATAFMT *) malloc(num_cols * sizeof(CS_DATAFMT));			if (outdatafmt == NULL) {				fprintf(stderr, "malloc outdatafmt failed \n");				return 1;			}			for (i = 0; i < num_cols; i++) {				ret = ct_describe(cmd, (i + 1), &outdatafmt[i]);				if (ret != CS_SUCCEED) {					fprintf(stderr, "ct_describe failed \n");					return 1;				}				outdatafmt[i].maxlength = ex_display_dlen(&outdatafmt[i]) + 1;				outdatafmt[i].datatype = CS_CHAR_TYPE;				outdatafmt[i].format = CS_FMT_NULLTERM;				coldata[i].value = (CS_CHAR *) malloc(outdatafmt[i].maxlength);				coldata[i].value[0] = 0;				if (coldata[i].value == NULL) {					fprintf(stderr, "malloc coldata.value failed \n");					return 1;				}				ret = ct_bind(cmd, (i + 1), &outdatafmt[i], coldata[i].value, &coldata[i].valuelen,					      & coldata[i].indicator);				if (ret != CS_SUCCEED) {					fprintf(stderr, "ct_bind failed \n");					return 1;				}			}			if (ret != CS_SUCCEED) {				for (j = 0; j < i; j++) {					free(coldata[j].value);				}				free(coldata);				free(outdatafmt);				return 1;			}			ex_display_header(num_cols, outdatafmt);			while (((ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED,						&rows_read)) == CS_SUCCEED) || (ret == CS_ROW_FAIL)) {				/*				 * Increment our row count by the number of rows just fetched.				 */				row_count = row_count + rows_read;				/*				 * Check if we hit a recoverable error.				 */				if (ret == CS_ROW_FAIL) {					fprintf(stdout, "Error on row %d.\n", row_count);					fflush(stdout);				}				/*				 * We have a row.  Loop through the columns displaying the				 * column values.				 */				for (i = 0; i < num_cols; i++) {					/*					 * Display the column value					 */					fprintf(stdout, "%s", coldata[i].value);					fflush(stdout);					/*					 * If not last column, Print out spaces between this					 * column and next one.					 */					if (i != num_cols - 1) {						disp_len = ex_display_dlen(&outdatafmt[i]);						disp_len -= coldata[i].valuelen - 1;						for (j = 0; j < disp_len; j++) {							fputc(' ', stdout);						}					}				}				fprintf(stdout, "\n");				fflush(stdout);			}			/*			 * Free allocated space.			 */			for (i = 0; i < num_cols; i++) {				free(coldata[i].value);			}			free(coldata);			free(outdatafmt);			/*			 * We're done processing rows.  Let's check the final return			 * value of ct_fetch().			 */			switch ((int) ret) {			case CS_END_DATA:				/*				 * Everything went fine.				 */				fprintf(stdout, "All done processing rows.\n");				fflush(stdout);				break;			case CS_FAIL:				/*				 * Something terrible happened.				 */				fprintf(stderr, "ct_fetch returned CS_FAIL\n");				return 1;				break;			default:				/*				 * We got an unexpected return value.				 */				fprintf(stderr, "ct_fetch returned %d\n", ret);				return 1;				break;			}			break;		case CS_MSG_RESULT:			ret = ct_res_info(cmd, CS_MSGTYPE, (CS_VOID *) & msg_id, CS_UNUSED, NULL);			if (ret != CS_SUCCEED) {				fprintf(stderr, "ct_res_info(msg_id) failed");				return 1;			}			fprintf(stdout, "ct_result returned CS_MSG_RESULT where msg id = %d.\n", msg_id);			fflush(stdout);			break;		case CS_CMD_SUCCEED:			/*			 * This means no rows were returned.			 */			break;		case CS_CMD_DONE:			/*			 * Done with result set.			 */			break;		case CS_CMD_FAIL:			/*			 * The server encountered an error while			 * processing our command.			 */			fprintf(stderr, "ct_results returned CS_CMD_FAIL.");			break;		default:			/*			 * We got something unexpected.			 */			fprintf(stderr, "ct_results returned unexpected result type.");			return CS_FAIL;		}	}	/*	 * We're done processing results. Let's check the	 * return value of ct_results() to see if everything	 * went ok.	 */	switch ((int) ret) {	case CS_END_RESULTS:		/*		 * Everything went fine.		 */		break;	case CS_FAIL:		/*		 * Something failed happened.		 */		fprintf(stderr, "ct_results failed.");		break;	default:		/*		 * We got an unexpected return value.		 */		fprintf(stderr, "ct_results returned unexpected result type.");		break;	}	return CS_SUCCEED;}static CS_INTex_display_dlen(CS_DATAFMT *column){CS_INT len;	switch ((int) column->datatype) {	case CS_CHAR_TYPE:	case CS_VARCHAR_TYPE:	case CS_TEXT_TYPE:	case CS_IMAGE_TYPE:		len = MIN(column->maxlength, 1024);		break;	case CS_BINARY_TYPE:	case CS_VARBINARY_TYPE:		len = MIN((2 * column->maxlength) + 2, 1024);		break;	case CS_BIT_TYPE:	case CS_TINYINT_TYPE:		len = 3;		break;	case CS_SMALLINT_TYPE:		len = 6;		break;	case CS_INT_TYPE:		len = 11;		break;	case CS_REAL_TYPE:	case CS_FLOAT_TYPE:		len = 20;		break;	case CS_MONEY_TYPE:	case CS_MONEY4_TYPE:		len = 24;		break;	case CS_DATETIME_TYPE:	case CS_DATETIME4_TYPE:		len = 30;		break;	case CS_NUMERIC_TYPE:	case CS_DECIMAL_TYPE:		len = (CS_MAX_PREC + 2);		break;	default:		len = 12;		break;	}	return MAX((CS_INT) (strlen(column->name) + 1), len);}static CS_RETCODEex_display_header(CS_INT numcols, CS_DATAFMT columns[]){CS_INT i;CS_INT l;CS_INT j;CS_INT disp_len;	fputc('\n', stdout);	for (i = 0; i < numcols; i++) {		disp_len = ex_display_dlen(&columns[i]);		fprintf(stdout, "%s", columns[i].name);		fflush(stdout);		l = disp_len - strlen(columns[i].name);		for (j = 0; j < l; j++) {			fputc(' ', stdout);			fflush(stdout);		}	}	fputc('\n', stdout);	fflush(stdout);	for (i = 0; i < numcols; i++) {		disp_len = ex_display_dlen(&columns[i]);		l = disp_len - 1;		for (j = 0; j < l; j++) {			fputc('-', stdout);		}		fputc(' ', stdout);	}	fputc('\n', stdout);	return CS_SUCCEED;}CS_RETCODEex_clientmsg_cb(CS_CONTEXT * context, CS_CONNECTION * connection, CS_CLIENTMSG * errmsg){	fprintf(stdout, "\nOpen Client Message:\n");	fprintf(stdout, "Message number: LAYER = (%ld) ORIGIN = (%ld) ", (long) CS_LAYER(errmsg->msgnumber), (long) CS_ORIGIN(errmsg->msgnumber));	fprintf(stdout, "SEVERITY = (%ld) NUMBER = (%ld)\n", (long) CS_SEVERITY(errmsg->msgnumber), (long) CS_NUMBER(errmsg->msgnumber));	fprintf(stdout, "Message String: %s\n", errmsg->msgstring);	if (errmsg->osstringlen > 0) {		fprintf(stdout, "Operating System Error: %s\n", errmsg->osstring);	}	fflush(stdout);	return CS_SUCCEED;}CS_RETCODEex_servermsg_cb(CS_CONTEXT * context, CS_CONNECTION * connection, CS_SERVERMSG * srvmsg){	fprintf(stdout, "\nServer message:\n");	fprintf(stdout, "Message number: %ld, Severity %ld, ", (long) srvmsg->msgnumber, (long) srvmsg->severity);	fprintf(stdout, "State %ld, Line %ld\n", (long) srvmsg->state, (long) srvmsg->line);	if (srvmsg->svrnlen > 0) {		fprintf(stdout, "Server '%s'\n", srvmsg->svrname);	}	if (srvmsg->proclen > 0) {		fprintf(stdout, " Procedure '%s'\n", srvmsg->proc);	}	fprintf(stdout, "Message String: %s\n", srvmsg->text);	fflush(stdout);	return CS_SUCCEED;}