void threadRun( MessagingPort * inPort) {
TicketHolderReleaser connTicketReleaser( &Listener::globalTicketHolder );
{
string threadName = "conn";
if ( inPort->connectionId() > 0 )
threadName = str::stream() << threadName << inPort->connectionId();
setThreadName( threadName.c_str() );
}
verify( inPort );
inPort->psock->setLogLevel(1);
scoped_ptr<MessagingPort> p( inPort );
p->psock->postFork();
string otherSide;
Message m;
try {
LastError * le = new LastError();
lastError.reset( le ); // lastError now has ownership
otherSide = p->psock->remoteString();
handler->connected( p.get() );
while ( ! inShutdown() ) {
m.reset();
p->psock->clearCounters();
if ( ! p->recv(m) ) {
if( !cmdLine.quiet ){
int conns = Listener::globalTicketHolder.used()-1;
const char* word = (conns == 1 ? " connection" : " connections");
log() << "end connection " << otherSide << " (" << conns << word << " now open)" << endl;
}
p->shutdown();
break;
}
handler->process( m , p.get() , le );
networkCounter.hit( p->psock->getBytesIn() , p->psock->getBytesOut() );
}
}
catch ( AssertionException& e ) {
log() << "AssertionException handling request, closing client connection: " << e << endl;
p->shutdown();
}
catch ( SocketException& e ) {
log() << "SocketException handling request, closing client connection: " << e << endl;
p->shutdown();
}
catch ( const DBException& e ) { // must be right above std::exception to avoid catching subclasses
log() << "DBException handling request, closing client connection: " << e << endl;
p->shutdown();
}
catch ( std::exception &e ) {
error() << "Uncaught std::exception: " << e.what() << ", terminating" << endl;
dbexit( EXIT_UNCAUGHT );
}
catch ( ... ) {
error() << "Uncaught exception, terminating" << endl;
dbexit( EXIT_UNCAUGHT );
}
handler->disconnected( p.get() );
}
int
main(int argc, char *argv[])
{
LOGINREC *login;
DBPROCESS *dbproc;
int i;
RETCODE ret;
int big_endian = 1;
char *out_file = "t0017.out";
static const char in_file_le[] = FREETDS_SRCDIR "/t0017.in";
static const char in_file_be[] = FREETDS_SRCDIR "/t0017.in.be";
const char *in_file = in_file_le;
const char *err_file = "t0017.err";
DBINT rows_copied;
int num_cols = 0;
int col_type[256];
DBBOOL col_varylen[256];
int prefix_len;
if (((char *) &big_endian)[0] == 1)
big_endian = 0;
if (big_endian)
in_file = in_file_be;
setbuf(stdout, NULL);
setbuf(stderr, NULL);
set_malloc_options();
read_login_info(argc, argv);
printf("Starting %s\n", software_version);
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
printf("About to logon ... ");
login = dblogin();
assert(login);
BCP_SETL(login, TRUE);
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0017");
printf("done\n");
printf("Opening \"%s\" for \"%s\" ... ", SERVER, USER);
dbproc = dbopen(login, SERVER);
assert(dbproc);
if (strlen(DATABASE)) {
dbuse(dbproc, DATABASE);
}
dbloginfree(login);
printf("done\n");
printf("Creating table ... ");
dbcmd(dbproc, "create table #dblib0017 (c1 int null, c2 text)");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
printf("done\n");
dbcmd(dbproc, "insert into #dblib0017(c1,c2) values(1144201745,'prova di testo questo testo dovrebbe andare a finire in un campo text')");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
/* BCP out */
printf("bcp_init... ");
ret = bcp_init(dbproc, "#dblib0017", out_file, err_file, DB_OUT);
if (ret != SUCCEED)
failed = 1;
printf("done\n");
printf("Issuing SELECT ... ");
dbcmd(dbproc, "select * from #dblib0017 where 0=1");
dbsqlexec(dbproc);
printf("done\nFetching metadata ... ");
if (dbresults(dbproc) != FAIL) {
num_cols = dbnumcols(dbproc);
for (i = 0; i < num_cols; ++i) {
col_type[i] = dbcoltype(dbproc, i + 1);
col_varylen[i] = dbvarylen(dbproc, i + 1);
}
while (dbnextrow(dbproc) != NO_MORE_ROWS) {
}
}
printf("done\n");
printf("bcp_columns ... ");
ret = bcp_columns(dbproc, num_cols);
if (ret != SUCCEED)
failed = 1;
for (i = 0; i < num_cols; i++) {
prefix_len = 0;
if (col_type[i] == SYBIMAGE || col_type[i] == SYBTEXT) {
prefix_len = 4;
} else if (col_varylen[i]) {
prefix_len = 1;
}
printf("bind %d prefix %d col_type %s\n", i, prefix_len, col_type[i] == SYBIMAGE ? "image" : "other");
ret = bcp_colfmt(dbproc, i + 1, col_type[i], prefix_len, -1, NULL, 0, i + 1);
if (ret == FAIL) {
fprintf(stderr, "return from bcp_colfmt = %d\n", ret);
failed = 1;
}
}
printf("done\n");
rows_copied = -1;
printf("bcp_exec ... ");
ret = bcp_exec(dbproc, &rows_copied);
if (ret != SUCCEED || rows_copied != 1)
failed = 1;
printf("%d rows copied\n", rows_copied);
/* delete rows */
dbcmd(dbproc, "delete from #dblib0017");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
/*
* BCP in
*/
printf("bcp_init... ");
ret = bcp_init(dbproc, "#dblib0017", in_file, err_file, DB_IN);
if (ret != SUCCEED)
failed = 1;
printf("done\n");
printf("Issuing SELECT ... ");
dbcmd(dbproc, "select * from #dblib0017 where 0=1");
dbsqlexec(dbproc);
printf("done\nFetching metadata ... ");
if (dbresults(dbproc) != FAIL) {
num_cols = dbnumcols(dbproc);
for (i = 0; i < num_cols; i++) {
col_type[i] = dbcoltype(dbproc, i + 1);
col_varylen[i] = dbvarylen(dbproc, i + 1);
}
while (dbnextrow(dbproc) != NO_MORE_ROWS) {
}
}
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
printf("done\n");
printf("bcp_columns ... ");
ret = bcp_columns(dbproc, num_cols);
if (ret != SUCCEED)
failed = 1;
for (i = 0; i < num_cols; i++) {
prefix_len = 0;
if (col_type[i] == SYBIMAGE || col_type[i] == SYBTEXT) {
prefix_len = 4;
} else if (col_varylen[i]) {
prefix_len = 1;
}
ret = bcp_colfmt(dbproc, i + 1, col_type[i], prefix_len, -1, NULL, 0, i + 1);
if (ret == FAIL) {
fprintf(stderr, "return from bcp_colfmt = %d\n", ret);
failed = 1;
}
}
printf("done\n");
printf("bcp_exec ... ");
rows_copied = -1;
ret = bcp_exec(dbproc, &rows_copied);
if (ret != SUCCEED || rows_copied != 1)
failed = 1;
printf("done\n");
/* test we inserted correctly row */
if (!failed) {
dbcmd(dbproc, "SET NOCOUNT ON DECLARE @n INT SELECT @n = COUNT(*) FROM #dblib0017 WHERE c1=1144201745 AND c2 LIKE 'prova di testo questo testo dovrebbe andare a finire in un campo text' IF @n <> 1 SELECT 0");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
while ((ret=dbnextrow(dbproc)) != NO_MORE_ROWS) {
fprintf(stderr, "Invalid dbnextrow result %d executing query\n", ret);
failed = 1;
}
}
}
printf("%d rows copied\n", rows_copied);
dbclose(dbproc);
dbexit();
printf("dblib %s on %s\n", (failed ? "failed!" : "okay"), __FILE__);
return failed ? 1 : 0;
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
DBINT testint;
STATUS rc;
int i, iresults;
char teststr[1024];
const int buffer_count = 10;
const int rows_to_add = 50;
const char tablename[] = "#dblib0002";
const char drop_if_exists[] = "if exists ( select 1 "
"from tempdb..sysobjects "
"where id = object_id('tempdb..%s') )\n"
"\tdrop table %s\n";
set_malloc_options();
read_login_info(argc, argv);
fprintf(stdout, "Start\n");
add_bread_crumb();
/* Fortify_EnterScope(); */
dbinit();
add_bread_crumb();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
add_bread_crumb();
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0002");
fprintf(stdout, "About to open %s..%s\n", SERVER, DATABASE);
add_bread_crumb();
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
add_bread_crumb();
dbloginfree(login);
add_bread_crumb();
fprintf(stdout, "Setting row buffer to 10 rows\n");
#ifdef MICROSOFT_DBLIB
dbsetopt(dbproc, DBBUFFER, "10");
#else
dbsetopt(dbproc, DBBUFFER, "10", 0);
#endif
add_bread_crumb();
add_bread_crumb();
fprintf(stdout, drop_if_exists, tablename, tablename);
dbfcmd(dbproc, drop_if_exists, tablename, tablename);
add_bread_crumb();
dbsqlexec(dbproc);
add_bread_crumb();
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
if (dbresults(dbproc) != NO_MORE_RESULTS) {
fprintf(stdout, "Failed: dbresults call after NO_MORE_RESULTS should return NO_MORE_RESULTS.\n");
failed = 1;
}
add_bread_crumb();
fprintf(stdout, "create table %s (i int not null, s char(10) not null)\n", tablename);
dbfcmd(dbproc, "create table %s (i int not null, s char(10) not null)", tablename);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "insert into %s [%d rows]\n", tablename, rows_to_add);
for (i = 1; i <= rows_to_add; i++) {
char cmd[1024];
sprintf(cmd, "insert into %s values (%d, 'row %03d')", tablename, i, i);
dbcmd(dbproc, cmd);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
fprintf(stdout, "select * from %s order by i\n", tablename);
dbfcmd(dbproc, "select * from %s order by i\n", tablename);
dbfcmd(dbproc, "select * from %s order by i\n", tablename); /* two result sets */
dbsqlexec(dbproc);
add_bread_crumb();
for (iresults=1; iresults <= 2; iresults++ ) {
fprintf(stdout, "fetching resultset %i\n", iresults);
if (dbresults(dbproc) != SUCCEED) {
add_bread_crumb();
fprintf(stderr, "Was expecting a result set %d.\n", iresults);
if( iresults == 2 )
fprintf(stderr, "Buffering with multiple resultsets is broken.\n");
exit(1);
}
add_bread_crumb();
for (i = 1; i <= dbnumcols(dbproc); i++) {
add_bread_crumb();
printf("col %d is [%s]\n", i, dbcolname(dbproc, i));
add_bread_crumb();
}
add_bread_crumb();
dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint);
add_bread_crumb();
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
add_bread_crumb();
/* Fetch a result set */
/* Second resultset stops at row 40 */
for (i=0; i < rows_to_add - (iresults == 2 ? buffer_count : 0);) {
fprintf(stdout, "clearing %d rows from buffer\n", buffer_count);
dbclrbuf(dbproc, buffer_count);
do {
int rc;
i++;
add_bread_crumb();
if (REG_ROW != (rc = dbnextrow(dbproc))) {
failed = 1;
fprintf(stderr, "Failed: Expected a row (%s:%d)\n", __FILE__, __LINE__);
if (rc == BUF_FULL)
fprintf(stderr, "Failed: dbnextrow returned BUF_FULL (%d). Fix dbclrbuf.\n", rc);
exit(1);
}
add_bread_crumb();
verify(i, testint, teststr);
} while (i % buffer_count);
if (iresults == 1 && i == rows_to_add) {
/* The buffer should be full */
assert(BUF_FULL == dbnextrow(dbproc));
}
}
if (iresults == 1) {
fprintf(stdout, "clearing %d rows from buffer\n", buffer_count);
dbclrbuf(dbproc, buffer_count);
while (dbnextrow(dbproc) != NO_MORE_ROWS) {
abort(); /* All rows were read: should not enter loop */
}
}
}
/*
* Now test the buffered rows.
* Should be operating on rows 31-40 of 2nd resultset
*/
rc = dbgetrow(dbproc, 1);
add_bread_crumb();
if(rc != NO_MORE_ROWS) /* row 1 is not among the 31-40 in the buffer */
fprintf(stderr, "Failed: dbgetrow returned %d.\n", rc);
assert(rc == NO_MORE_ROWS);
rc = dbgetrow(dbproc, 31);
add_bread_crumb();
if(rc != REG_ROW)
fprintf(stderr, "Failed: dbgetrow returned %d.\n", rc);
assert(rc == REG_ROW);
verify(31, testint, teststr); /* first buffered row should be 31 */
rc = dbnextrow(dbproc);
add_bread_crumb();
if(rc != REG_ROW)
fprintf(stderr, "Failed: dbgetrow returned %d.\n", rc);
assert(rc == REG_ROW);
verify(32, testint, teststr); /* next buffered row should be 32 */
rc = dbgetrow(dbproc, 11);
add_bread_crumb();
assert(rc == NO_MORE_ROWS); /* only 10 (not 11) rows buffered */
rc = dbgetrow(dbproc, 40);
add_bread_crumb();
assert(rc == REG_ROW);
verify(40, testint, teststr); /* last buffered row should be 40 */
/* Attempt dbnextrow when buffer has no space (10 out of 10 in use). */
rc = dbnextrow(dbproc);
assert(rc == BUF_FULL);
dbclrbuf(dbproc, 3); /* remove rows 31, 32, and 33 */
rc = dbnextrow(dbproc);
add_bread_crumb();
assert(rc == REG_ROW);
verify(41, testint, teststr); /* fetch row from database, should be 41 */
rc = dbnextrow(dbproc);
add_bread_crumb();
assert(rc == REG_ROW);
verify(42, testint, teststr); /* fetch row from database, should be 42 */
/* buffer contains 9 rows (34-42) try removing 10 rows */
dbclrbuf(dbproc, buffer_count);
while (dbnextrow(dbproc) != NO_MORE_ROWS) {
/* waste rows 43-50 */
}
dbclose(dbproc); /* close while buffer not cleared: OK */
add_bread_crumb();
dbexit();
add_bread_crumb();
fprintf(stdout, "dblib %s on %s\n", (failed ? "failed!" : "okay"), __FILE__);
free_bread_crumb();
return failed ? 1 : 0;
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
RETCODE ret;
int expected_error;
set_malloc_options();
read_login_info(argc, argv);
fprintf(stdout, "Starting %s\n", argv[0]);
add_bread_crumb();
/* Fortify_EnterScope(); */
dbinit();
add_bread_crumb();
dberrhandle(err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
add_bread_crumb();
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0020");
fprintf(stdout, "About to open\n");
add_bread_crumb();
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
add_bread_crumb();
dbloginfree(login);
add_bread_crumb();
sql_cmd(dbproc);
fprintf(stderr, "The following invalid column error is normal.\n");
expected_error = 207;
dbsetuserdata(dbproc, (BYTE*) &expected_error);
ret = dbsqlexec(dbproc);
if (ret != FAIL) {
failed = 1;
fprintf(stderr, "Failed. Expected FAIL to be returned.\n");
exit(1);
}
sql_cmd(dbproc);
ret = dbsqlexec(dbproc);
if (ret != SUCCEED) {
failed = 1;
fprintf(stderr, "Failed. Expected SUCCEED to be returned.\n");
exit(1);
}
while (dbresults(dbproc) != NO_MORE_RESULTS) {
while (dbnextrow(dbproc) != NO_MORE_ROWS);
}
add_bread_crumb();
dbexit();
add_bread_crumb();
fprintf(stdout, "%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
free_bread_crumb();
return failed ? 1 : 0;
}
void exitCleanly(ExitCode code)
{
dbexit(code);
}
int
main(int argc, char **argv)
{
const int rows_to_add = 50;
LOGINREC *login;
DBPROCESS *dbproc;
int i;
char teststr[1024];
DBINT testint;
set_malloc_options();
read_login_info(argc, argv);
fprintf(stdout, "Starting %s\n", argv[0]);
/* Fortify_EnterScope(); */
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0015");
fprintf(stdout, "About to open\n");
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
fprintf(stdout, "creating table\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "insert\n");
for (i = 0; i < rows_to_add; i++) {
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
fprintf(stdout, "select\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
failed = 1;
fprintf(stdout, "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)) {
failed = 1;
fprintf(stderr, "Had problem with bind\n");
abort();
}
if (SUCCEED != dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr)) {
failed = 1;
fprintf(stderr, "Had problem with bind\n");
abort();
}
if (REG_ROW != dbnextrow(dbproc)) {
failed = 1;
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
dbcancel(dbproc);
fprintf(stdout, "select 2\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
failed = 1;
fprintf(stdout, "Was expecting a result set.");
exit(1);
}
if (SUCCEED != dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint)) {
failed = 1;
fprintf(stderr, "Had problem with bind\n");
abort();
}
if (SUCCEED != dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr)) {
failed = 1;
fprintf(stderr, "Had problem with bind\n");
abort();
}
for (i = 26; i < rows_to_add; i++) {
char expected[1024];
sprintf(expected, "row %03d", i);
if (REG_ROW != dbnextrow(dbproc)) {
failed = 1;
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
if (testint != i) {
failed = 1;
fprintf(stderr, "Failed. Expected i to be %d, was %d\n", i, (int) testint);
abort();
}
if (0 != strncmp(teststr, expected, strlen(expected))) {
failed = 1;
fprintf(stdout, "Failed. Expected s to be |%s|, was |%s|\n", expected, teststr);
abort();
}
printf("Read a row of data -> %d %s\n", (int) testint, teststr);
}
if (dbnextrow(dbproc) != NO_MORE_ROWS) {
failed = 1;
fprintf(stderr, "Was expecting no more rows\n");
exit(1);
}
dbexit();
fprintf(stdout, "%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
int
main(int argc, char *argv[])
{
int echo = 0;
#ifdef notyet
int print_statistics = 0;
#endif
int fipsflagger = 0;
int perfstats = 0;
int use_encryption = 0;
int chained_transactions = 0;
int headers = 0;
char *columnwidth = NULL;
const char *colseparator = " ";
const char *lineseparator = "\n";
int timeout = 0;
char *username = NULL;
char *password = NULL;
char *server = NULL;
DBCHAR *char_set = NULL;
char *hostname = NULL;
char *interfaces_filename = NULL;
char *input_filename = NULL;
char *output_filename = NULL;
int logintime = -1;
char *language = NULL;
int size = 0;
char *sybenv;
LOGINREC *login;
int printedlines;
int i;
int dbrc;
int c;
int errflg = 0;
char *prbuf;
int prbuflen;
int num_cols;
int selcol;
int col;
int collen;
DBINT colid;
const char *opname;
char adbuf[512];
DBINT convlen;
int printedcompute = 0;
char adash;
const char *database_name = NULL;
setlocale(LC_ALL, "");
#ifdef __VMS
/* Convert VMS-style arguments to Unix-style */
parse_vms_args(&argc, &argv);
#endif
editor = getenv("EDITOR");
if (!editor) {
editor = getenv("VISUAL");
}
if (!editor) {
editor = "vi";
}
opterr = 0;
optarg = NULL;
while (!errflg && (c = getopt(argc, argv, "eFgpnvXYa:c:D:E:h:H:i:I:J:l:m:o:P:s:S:t:U:w:y:z:A:"))
!= -1) {
switch (c) {
case 'e':
echo = 1;
break;
case 'F':
fipsflagger = 1;
break;
case 'g':
errflg++;
break;
case 'p':
errflg++;
perfstats = 1;
break;
case 'n':
no_prompt = 1;
break;
case 'v':
puts("fisql, a free isql replacement by Nicholas S. Castellano");
return EXIT_SUCCESS;
break;
case 'X':
/* XXX: We get a different error message than isql gives; neither seems
* to work
*/
use_encryption = 1;
break;
case 'Y':
chained_transactions = 1;
break;
case 'c':
cmdend = optarg;
break;
case 'E':
editor = optarg;
break;
case 'h':
headers = atoi(optarg);
break;
case 'H':
hostname = optarg;
break;
case 'i':
input_filename = optarg;
break;
case 'I':
interfaces_filename = optarg;
break;
case 'J':
errflg++;
break;
case 'l':
logintime = atoi(optarg);
break;
case 'm':
global_errorlevel = atoi(optarg);
break;
case 'o':
output_filename = optarg;
break;
case 'P':
password = optarg;
break;
case 's':
colseparator = optarg;
break;
case 'S':
server = optarg;
break;
case 't':
timeout = atoi(optarg);
break;
case 'U':
username = optarg;
break;
case 'w':
columnwidth = optarg;
break;
case 'y':
/* XXX: this doesn't seem to be what isql does with -y...it doesn't
* seem to do anything actually
*/
sybenv = (char *) xmalloc((strlen(optarg) + 8) * sizeof(char));
strcpy(sybenv, "SYBASE=");
strcat(sybenv, optarg);
putenv(sybenv);
break;
case 'z':
language = optarg;
break;
case 'A':
size = atoi(optarg);
break;
case 'D':
database_name = optarg;
break;
default:
errflg++;
break;
}
}
if (errflg) {
fprintf(stderr, "usage: fisql [-e] [-F] [-g] [-p] [-n] [-v] [-X] [-Y]\n");
fprintf(stderr, "\t[-c cmdend] [-D database_name] [-E editor]\n");
fprintf(stderr, "\t[-h headers] [-H hostname] [-i inputfile]\n");
fprintf(stderr, "\t[-I interfaces_file] [-J client character set]\n");
fprintf(stderr, "\t[-l login_timeout] [-m errorlevel]\n");
fprintf(stderr, "\t[-o outputfile]\n");
fprintf(stderr, "\t[-P password] [-s colseparator] [-S server]\n");
fprintf(stderr, "\t[-t timeout] [-U username] [-w columnwidth]\n");
fprintf(stderr, "\t[-y sybase_dir] [-z language]\n");
return EXIT_FAILURE;
}
if (!(isatty(fileno(stdin)))) {
no_prompt = 1;
rl_outstream = fopen("/dev/null", "rw");
}
rl_readline_name = "fisql";
rl_bind_key('\t', rl_insert);
if (password == NULL) {
password = (char *) xmalloc(READPASSPHRASE_MAXLEN);
readpassphrase("Password: "******"r", stdin) == NULL) {
/* XXX: sybase isql generates this error while parsing the options,
* but doesn't redirect the input until after the Password: prompt
*/
/* lack of newline for bug-compatibility with isql */
fprintf(stderr, "Unable to open input file '%s'.", optarg);
return EXIT_FAILURE;
}
}
if (output_filename) {
if (freopen(output_filename, "w", stdout) == NULL) {
/* XXX: sybase isql generates this error while parsing the options,
* but doesn't redirect the output until after the Password: prompt
*/
/* lack of newline for bug-compatibility with isql */
fprintf(stderr, "Unable to open output file '%s'.", output_filename);
return EXIT_FAILURE;
}
}
if (isatty(fileno(stdin))) {
rl_outstream = stdout;
}
dbinit();
#if 0
#ifdef DBVERSION_100
dbsetversion(DBVERSION_100);
#endif
#endif
if ((login = dblogin()) == NULL) {
reset_term();
return EXIT_FAILURE;
}
dbmsghandle(msg_handler);
dberrhandle(err_handler);
DBSETLAPP(login, "fisql");
if (username) {
DBSETLUSER(login, username);
}
DBSETLPWD(login, password);
memset(password, 0, strlen(password));
if (char_set) {
DBSETLCHARSET(login, char_set);
}
if (use_encryption) {
DBSETLENCRYPT(login, TRUE);
}
if (hostname) {
DBSETLHOST(login, hostname);
}
if (language) {
DBSETLNATLANG(login, language);
}
if (size) {
DBSETLPACKET(login, (short) size);
}
if (interfaces_filename) {
dbsetifile(interfaces_filename);
}
dbsettime(timeout);
if (logintime >= 0) {
dbsetlogintime(logintime);
}
if (database_name) {
DBSETLDBNAME(login, database_name);
}
if ((dbproc = dbopen(login, server)) == NULL) {
fprintf(stderr, "fisql: dbopen() failed.\n");
reset_term();
return EXIT_FAILURE;
}
dbsetopt(dbproc, DBPRLINESEP, lineseparator, strlen(lineseparator));
if (colseparator) {
dbsetopt(dbproc, DBPRCOLSEP, colseparator, strlen(colseparator));
}
if (columnwidth) {
dbsetopt(dbproc, DBPRLINELEN, columnwidth, 0);
}
if (chained_transactions) {
dbsetopt(dbproc, DBCHAINXACTS, NULL, 0);
}
if (fipsflagger) {
dbsetopt(dbproc, DBFIPSFLAG, NULL, 0);
}
if (perfstats) {
dbsetopt(dbproc, DBSTAT, "time", 0);
}
while (1) {
if (sigsetjmp(restart, 1)) {
reset_ibuf();
fputc('\n', stdout);
rl_on_new_line();
rl_reset_line_state();
}
dbcancel(dbproc);
signal(SIGINT, inactive_interrupt_handler);
read_sql_lines();
dbfreebuf(dbproc);
for (i = 0; i < ibuflines; i++) {
if (echo) {
puts(ibuf[i]);
}
dbcmd(dbproc, ibuf[i]);
dbcmd(dbproc, "\n");
free(ibuf[i]);
}
free(ibuf);
ibuf = NULL;
signal(SIGINT, active_interrupt_handler);
dbsetinterrupt(dbproc, (void *) active_interrupt_pending, (void *) active_interrupt_servhandler);
if (dbsqlexec(dbproc) == SUCCEED) {
int status_printed = 0;
maybe_handle_active_interrupt();
while ((dbrc = dbresults(dbproc)) != NO_MORE_RESULTS) {
printedlines = 0;
#define USE_DBPRROW 0
#if USE_DBPRROW
dbprhead(dbproc);
dbprrow(dbproc);
#else
if ((dbrc == SUCCEED) && (DBROWS(dbproc) == SUCCEED)) {
prbuflen = dbspr1rowlen(dbproc);
prbuf = (char *) xmalloc(prbuflen * sizeof(char));
dbsprhead(dbproc, prbuf, prbuflen);
fputs(prbuf, stdout);
fputc('\n', stdout);
dbsprline(dbproc, prbuf, prbuflen, '-');
fputs(prbuf, stdout);
fputc('\n', stdout);
maybe_handle_active_interrupt();
while ((dbrc = dbnextrow(dbproc)) != NO_MORE_ROWS) {
if (dbrc == FAIL) {
break;
}
if (dbrc != REG_ROW) {
num_cols = dbnumalts(dbproc, dbrc);
for (selcol = col = 1; col <= num_cols; col++) {
colid = dbaltcolid(dbproc, dbrc, col);
while (selcol < colid) {
collen = get_printable_column_size(dbproc, selcol);
for (i = 0; i < collen; i++) {
putchar(' ');
}
selcol++;
printf("%s", colseparator);
}
opname = dbprtype(dbaltop(dbproc, dbrc, col));
printf("%s", opname);
collen = get_printable_column_size(dbproc, colid);
collen -= strlen(opname);
while (collen-- > 0) {
putchar(' ');
}
selcol++;
printf("%s", colseparator);
}
printf("%s", lineseparator);
for (selcol = col = 1; col <= num_cols; col++) {
colid = dbaltcolid(dbproc, dbrc, col);
while (selcol < colid) {
collen = get_printable_column_size(dbproc, selcol);
for (i = 0; i < collen; i++) {
putchar(' ');
}
selcol++;
printf("%s", colseparator);
}
collen = get_printable_column_size(dbproc, colid);
adash = '-';
for (i = 0; i < collen; i++) {
putchar(adash);
}
selcol++;
printf("%s", colseparator);
}
printf("%s", lineseparator);
for (selcol = col = 1; col <= num_cols; col++) {
colid = dbaltcolid(dbproc, dbrc, col);
while (selcol < colid) {
collen = get_printable_column_size(dbproc, selcol);
for (i = 0; i < collen; i++) {
putchar(' ');
}
selcol++;
printf("%s", colseparator);
}
convlen = dbconvert(dbproc,
dbalttype(dbproc, dbrc, col),
dbadata(dbproc, dbrc, col),
dbadlen(dbproc, dbrc, col),
SYBCHAR, (BYTE *) adbuf, sizeof(adbuf));
printf("%.*s", (int) convlen, adbuf);
collen = get_printable_column_size(dbproc, colid);
collen -= convlen;
while (collen-- > 0) {
putchar(' ');
}
selcol++;
printf("%s", colseparator);
}
printf("%s", lineseparator);
printedcompute = 1;
continue;
}
if (printedcompute || (headers && (printedlines >= headers)
&& ((printedlines % headers) == 0))) {
fputc('\n', stdout);
dbsprhead(dbproc, prbuf, prbuflen);
fputs(prbuf, stdout);
fputc('\n', stdout);
dbsprline(dbproc, prbuf, prbuflen, '-');
fputs(prbuf, stdout);
fputc('\n', stdout);
printedcompute = 0;
}
printedlines++;
dbspr1row(dbproc, prbuf, prbuflen);
fputs(prbuf, stdout);
fputc('\n', stdout);
maybe_handle_active_interrupt();
}
fputc('\n', stdout);
free(prbuf);
maybe_handle_active_interrupt();
}
#endif
if (dbrc != FAIL) {
if ((DBCOUNT(dbproc) >= 0) || dbhasretstat(dbproc)) {
if (DBCOUNT(dbproc) >= 0) {
fprintf(stdout, "(%d rows affected", (int) DBCOUNT(dbproc));
if (dbhasretstat(dbproc)) {
status_printed = 1;
dbrc = dbretstatus(dbproc);
fprintf(stdout, ", return status = %d", dbrc);
}
fprintf(stdout, ")\n");
} else {
if (dbhasretstat(dbproc)) {
status_printed = 1;
dbrc = dbretstatus(dbproc);
fprintf(stdout, "(return status = %d)\n", dbrc);
}
}
}
}
}
if (!status_printed && dbhasretstat(dbproc)) {
dbrc = dbretstatus(dbproc);
fprintf(stdout, "(return status = %d)\n", dbrc);
}
} else {
/* Something failed, so change the default
* exit status to reflect that.
*/
default_exit = EXIT_FAILURE;
}
}
reset_term();
dbexit();
return EXIT_FAILURE;
}
int
main(int argc, char **argv)
{
const int rows_to_add = 3;
LOGINREC *login;
DBPROCESS *dbproc;
DBPROCESS *blobproc;
int i;
DBINT testint;
FILE *fp;
long result, isiz;
char *blob, *rblob;
unsigned char *textPtr, *timeStamp;
char objname[256];
char sqlCmd[256];
char rbuf[BLOB_BLOCK_SIZE];
long numread;
BOOL readFirstImage;
set_malloc_options();
read_login_info(argc, argv);
fprintf(stdout, "Start\n");
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0014");
fprintf(stdout, "About to open %s..%s for user '%s'\n", SERVER, DATABASE, USER);
dbproc = dbopen(login, SERVER);
blobproc = dbopen(login, SERVER);
if (strlen(DATABASE)) {
dbuse(dbproc, DATABASE);
dbuse(blobproc, DATABASE);
}
dbloginfree(login);
fprintf(stdout, "After logon\n");
fprintf(stdout, "About to read binary input file\n");
if (argc == 1) {
argv = testargs;
argc = 3;
}
if (argc < 3) {
fprintf(stderr, "Usage: %s infile outfile\n", argv[0]);
return 1;
}
if ((fp = fopen(argv[1], "rb")) == NULL) {
fprintf(stderr, "Cannot open input file: %s\n", argv[1]);
return 2;
}
result = fseek(fp, 0, SEEK_END);
isiz = ftell(fp);
result = fseek(fp, 0, SEEK_SET);
blob = (char *) malloc(isiz);
fread((void *) blob, isiz, 1, fp);
fclose(fp);
/* FIXME this test seem to not work using temporary tables (sybase?)... */
fprintf(stdout, "Dropping table\n");
dbcmd(dbproc, "if object_id('dblib0014') is not null drop table dblib0014");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "creating table\n");
dbcmd(dbproc, "create table dblib0014 (i int not null, PigTure image not null)");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "insert\n");
for (i = 0; i < rows_to_add; i++) {
char cmd[1024];
sprintf(cmd, "insert into dblib0014 values (%d, '')", i);
fprintf(stdout, "%s\n", cmd);
dbcmd(dbproc, cmd);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
for (i = 0; i < rows_to_add; i++) {
sprintf(sqlCmd, "SELECT PigTure FROM dblib0014 WHERE i = %d", i);
dbcmd(dbproc, sqlCmd);
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
fprintf(stderr, "Error inserting blob\n");
return 4;
}
while ((result = dbnextrow(dbproc)) != NO_MORE_ROWS) {
result = REG_ROW;
result = DBTXPLEN;
strcpy(objname, "dblib0014.PigTure");
textPtr = dbtxptr(dbproc, 1);
timeStamp = dbtxtimestamp(dbproc, 1);
/*
* Use #ifdef if you want to test dbmoretext mode (needed for 16-bit apps)
* Use #ifndef for big buffer version (32-bit)
*/
#if 1
/* DBWRITE_OK_FOR_OVER_4K */
if (dbwritetext(blobproc, objname, textPtr, DBTXPLEN, timeStamp, TRUE, isiz, (BYTE*) blob) != SUCCEED)
return 5;
#else
if (dbwritetext(blobproc, objname, textPtr, DBTXPLEN, timeStamp, TRUE, isiz, NULL) != SUCCEED)
return 15;
dbsqlok(blobproc);
dbresults(blobproc);
numtowrite = 0;
/* Send the update value in chunks. */
for (numwritten = 0; numwritten < isiz; numwritten += numtowrite) {
numtowrite = (isiz - numwritten);
if (numtowrite > BLOB_BLOCK_SIZE)
numtowrite = BLOB_BLOCK_SIZE;
dbmoretext(blobproc, (DBINT) numtowrite, blob + numwritten);
}
dbsqlok(blobproc);
while (dbresults(blobproc) != NO_MORE_RESULTS);
#endif
}
}
fprintf(stdout, "select\n");
dbcmd(dbproc, "select * from dblib0014 order by i");
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
failed = 1;
fprintf(stdout, "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, -1, (BYTE *) & testint)) {
failed = 1;
fprintf(stderr, "Had problem with bind\n");
abort();
}
for (i = 0; i < rows_to_add; i++) {
char expected[1024];
sprintf(expected, "row %03d", i);
if (REG_ROW != dbnextrow(dbproc)) {
failed = 1;
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
if (testint != i) {
failed = 1;
fprintf(stderr, "Failed. Expected i to be %d, was %d\n", i, (int) testint);
abort();
}
/* get the image */
strcpy(sqlCmd, "SET TEXTSIZE 2147483647");
dbcmd(blobproc, sqlCmd);
dbsqlexec(blobproc);
if (dbresults(blobproc) != SUCCEED) {
dbcancel(blobproc);
return 16;
}
sprintf(sqlCmd, "SELECT PigTure FROM dblib0014 WHERE i = %d", i);
dbcmd(blobproc, sqlCmd);
dbsqlexec(blobproc);
if (dbresults(blobproc) != SUCCEED) {
fprintf(stderr, "Error extracting blob\n");
return 6;
}
numread = 0;
rblob = NULL;
readFirstImage = FALSE;
while ((result = dbreadtext(blobproc, rbuf, BLOB_BLOCK_SIZE)) != NO_MORE_ROWS) {
if (result == 0) { /* this indicates end of row */
readFirstImage = TRUE;
} else {
rblob = (char*) realloc(rblob, result + numread);
memcpy((void *) (rblob + numread), (void *) rbuf, result);
numread += result;
}
}
if (i == 0) {
printf("Saving first blob data row to file: %s\n", argv[2]);
if ((fp = fopen(argv[2], "wb")) == NULL) {
fprintf(stderr, "Unable to open output file: %s\n", argv[2]);
return 3;
}
result = fwrite((void *) rblob, numread, 1, fp);
fclose(fp);
}
printf("Read blob data row %d --> %s %ld byte comparison\n",
(int) testint, (memcmp(blob, rblob, numread)) ? "failed" : "PASSED", numread);
free(rblob);
}
if (dbnextrow(dbproc) != NO_MORE_ROWS) {
failed = 1;
fprintf(stderr, "Was expecting no more rows\n");
exit(1);
}
free(blob);
fprintf(stdout, "Dropping table\n");
dbcmd(dbproc, "drop table dblib0014");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
dbexit();
fprintf(stdout, "dblib %s on %s\n", (failed ? "failed!" : "okay"), __FILE__);
return failed ? 1 : 0;
}
int
main(int argc, char **argv)
{
const int rows_to_add = 10;
LOGINREC *login;
DBPROCESS *dbproc;
int i, nresults;
set_malloc_options();
read_login_info(argc, argv);
fprintf(stdout, "Starting %s\n", argv[0]);
/* Fortify_EnterScope(); */
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
login = dblogin();
fprintf(stdout, "after dblogin\n");
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0024");
fprintf(stdout, "About to open [%s]\n", USER);
dbproc = dbopen(login, SERVER);
fprintf(stdout, "After dbopen [%s]\n", SERVER);
if (strlen(DATABASE)) {
fprintf(stdout, "About to dbuse [%s]\n", DATABASE);
dbuse(dbproc, DATABASE);
}
dbloginfree(login);
fprintf(stdout, "After dbuse [%s]\n", DATABASE);
fprintf(stdout, "creating table\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
fprintf(stdout, "insert\n");
for (i = 0; i < rows_to_add; i++) {
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
fprintf(stdout, "select one resultset\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
nresults = 0;
if (dbresults(dbproc) == SUCCEED) {
do {
while (dbnextrow(dbproc) != NO_MORE_ROWS)
continue;
nresults++;
} while (dbmorecmds(dbproc) == SUCCEED);
}
/* dbmorecmds should return success 0 times for select 1 */
if (nresults != 1) {
failed = 1;
fprintf(stdout, "Was expecting nresults == 1.\n");
exit(1);
}
dbcancel(dbproc);
fprintf(stdout, "select two resultsets\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
nresults = 0;
do {
if (dbresults(dbproc) == SUCCEED) {
while (dbnextrow(dbproc) != NO_MORE_ROWS)
continue;
nresults++;
}
} while (dbmorecmds(dbproc) == SUCCEED);
/* dbmorecmds should return success 2 times for select 2 */
if (nresults != 2) { /* two results sets plus a return code */
failed = 1;
fprintf(stdout, "nresults was %d; was expecting nresults = 2.\n", nresults);
exit(1);
}
/* end of test processing */
dbexit();
fprintf(stdout, "%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
void exitCleanly(ExitCode rc) {
dbexit(rc, "");
}
int
main(int argc, char **argv)
{
const int rows_to_add = 50;
LOGINREC *login;
DBPROCESS *dbproc;
int i, expected_error;
char *s, teststr[1024];
DBINT testint;
int failed = 0;
set_malloc_options();
read_login_info(argc, argv);
fprintf(stdout, "Starting %s\n", argv[0]);
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0004");
fprintf(stdout, "About to open\n");
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
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 */
}
}
sql_cmd(dbproc); /* select */
dbsqlexec(dbproc);
if (dbresults(dbproc) != SUCCEED) {
fprintf(stdout, "Was expecting a result set.");
exit(1);
}
for (i = 1; i <= dbnumcols(dbproc); i++)
printf("col %d is %s\n", i, dbcolname(dbproc, i));
dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint);
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
for (i = 1; i <= 24; i++) {
char expected[1024];
sprintf(expected, "row %04d", i);
if (i % 5 == 0) {
dbclrbuf(dbproc, 5);
}
testint = -1;
strcpy(teststr, "bogus");
if (REG_ROW != dbnextrow(dbproc)) {
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
if (testint != i) {
fprintf(stderr, "Failed. Expected i to be %d, was %d\n", i, (int) testint);
abort();
}
if (0 != strncmp(teststr, expected, strlen(expected))) {
fprintf(stdout, "Failed. Expected s to be |%s|, was |%s|\n", expected, teststr);
abort();
}
printf("Read a row of data -> %d %s\n", (int) testint, teststr);
}
fprintf(stdout, "second select\n");
fprintf(stdout, "testing dbgetchar...\n");
for (i=0; (s = dbgetchar(dbproc, i)) != NULL; i++) {
putchar(*s);
if (!(isprint((unsigned char)*s) || iscntrl((unsigned char)*s))) {
fprintf(stderr, "%s:%d: dbgetchar failed with %x at position %d\n", __FILE__, __LINE__, *s, i);
failed = 1;
break;
}
}
fprintf(stdout, "<== end of command buffer\n");
if (SUCCEED != sql_cmd(dbproc)) {
fprintf(stderr, "%s:%d: dbcmd failed\n", __FILE__, __LINE__);
failed = 1;
}
fprintf(stdout, "About to exec for the second time. Should fail\n");
expected_error = 20019;
dbsetuserdata(dbproc, (BYTE*) &expected_error);
if (FAIL != dbsqlexec(dbproc)) {
fprintf(stderr, "%s:%d: dbsqlexec should have failed but didn't\n", __FILE__, __LINE__);
failed = 1;
}
dbexit();
fprintf(stdout, "%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
int
main(int argc, char **argv)
{
RETCODE rc;
const int rows_to_add = 50;
LOGINREC *login;
DBPROCESS *dbproc;
int i;
char teststr[1024];
DBINT testint;
set_malloc_options();
read_login_info(argc, argv);
printf("Starting %s\n", argv[0]);
/* Fortify_EnterScope(); */
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
printf("About to logon\n");
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0003");
DBSETLHOST(login, "ntbox.dntis.ro");
printf("About to open\n");
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
#ifdef MICROSOFT_DBLIB
dbsetopt(dbproc, DBBUFFER, "100");
#else
dbsetopt(dbproc, DBBUFFER, "100", 0);
#endif
printf("creating table\n");
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
printf("insert\n");
for (i = 1; i < rows_to_add; i++) {
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
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));
dbbind(dbproc, 1, INTBIND, 0, (BYTE *) & testint);
dbbind(dbproc, 2, STRINGBIND, 0, (BYTE *) teststr);
for (i = 1; i < rows_to_add; i++) {
char expected[1024];
sprintf(expected, "row %03d", i);
if (i % 100 == 0) {
dbclrbuf(dbproc, 100);
}
if (REG_ROW != dbnextrow(dbproc)) {
failed = 1;
fprintf(stderr, "Failed. Expected a row\n");
exit(1);
}
if (testint != i) {
failed = 1;
fprintf(stderr, "Failed. Expected i to be %d, was %d\n", i, (int) testint);
abort();
}
if (0 != strncmp(teststr, expected, strlen(expected))) {
failed = 1;
printf("Failed. Expected s to be |%s|, was |%s|\n", expected, teststr);
abort();
}
printf("Read a row of data -> %d %s\n", (int) testint, teststr);
}
dbclrbuf(dbproc, 1);
rc = dbnextrow(dbproc);
if (rc != NO_MORE_ROWS) {
failed = 1;
fprintf(stderr, "Was expecting no more rows. (rc=%d)\n", rc);
exit(1);
}
dbexit();
printf("%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
void rotate() {
if ( ! _enabled ) {
cout << "LoggingManager not enabled" << endl;
return;
}
if ( _file ) {
#ifdef POSIX_FADV_DONTNEED
posix_fadvise(fileno(_file), 0, 0, POSIX_FADV_DONTNEED);
#endif
// Rename the (open) existing log file to a timestamped name
stringstream ss;
ss << _path << "." << terseCurrentTime( false );
string s = ss.str();
rename( _path.c_str() , s.c_str() );
}
FILE* tmp = 0; // The new file using the original logpath name
#if _WIN32
// We rename an open log file (above, on next rotation) and the trick to getting Windows to do that is
// to open the file with FILE_SHARE_DELETE. So, we can't use the freopen() call that non-Windows
// versions use because it would open the file without the FILE_SHARE_DELETE flag we need.
//
HANDLE newFileHandle = CreateFileA(
_path.c_str(),
GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if ( INVALID_HANDLE_VALUE != newFileHandle ) {
int newFileDescriptor = _open_osfhandle( reinterpret_cast<intptr_t>(newFileHandle), _O_APPEND );
tmp = _fdopen( newFileDescriptor, _append ? "a" : "w" );
}
#else
tmp = freopen(_path.c_str(), _append ? "a" : "w", stdout);
#endif
if ( !tmp ) {
cerr << "can't open: " << _path.c_str() << " for log file" << endl;
dbexit( EXIT_BADOPTIONS );
assert( 0 );
}
// redirect stdout and stderr to log file
dup2( fileno( tmp ), 1 ); // stdout
dup2( fileno( tmp ), 2 ); // stderr
Logstream::setLogFile(tmp); // after this point no thread will be using old file
#if _WIN32
if ( _file )
fclose( _file ); // In Windows, we still have the old file open, close it now
#endif
#if 0 // enable to test redirection
cout << "written to cout" << endl;
cerr << "written to cerr" << endl;
log() << "written to log()" << endl;
#endif
_file = tmp; // Save new file for next rotation
}
void sighandler(int sig) {
dbexit(EXIT_CLEAN, (string("received signal ") + BSONObjBuilder::numStr(sig)).c_str());
}
static apr_status_t freetds_term(void *dummy)
{
dbexit();
regfree(&dbd_freetds_find_arg);
return APR_SUCCESS;
}
static void
read_sql_lines(void)
{
char *cp;
char *firstword;
char firstword_separator;
char *line = NULL;
char foobuf[40];
bool in_comment = false;
reset_ibuf();
while (1) {
if (no_prompt) {
foobuf[0] = '\0';
} else {
sprintf(foobuf, "%d>> ", ibuflines + 1);
}
free(line);
line = readline(foobuf);
if (line == NULL) {
reset_term();
dbexit();
exit(default_exit);
}
for (cp = line; *cp && isspace((unsigned char) *cp); cp++)
continue;
if (*cp) {
add_history(line);
}
if (in_comment) {
goto append_line;
}
if (!(strncasecmp(line, "!!", 2))) {
system_cmd(line + 2);
continue;
}
/* XXX: isql off-by-one line count error for :r not duplicated */
if (!(strncasecmp(line, ":r", 2))) {
readfile_cmd(line);
continue;
}
firstword = line;
firstword_separator = '\0';
for (cp = firstword; *cp; cp++) {
if (isspace((unsigned char) *cp)) {
firstword_separator = *cp;
*cp = '\0';
break;
}
}
if ((!(strcasecmp(firstword, "exit")))
|| (!(strcasecmp(firstword, "quit")))) {
reset_term();
dbexit();
exit(default_exit);
}
if (!(strcasecmp(firstword, "reset"))) {
reset_ibuf();
continue;
}
if (!(strcasecmp(firstword, cmdend))) {
if (ibuflines == 0) {
continue;
}
break;
}
if ((!(strcasecmp(firstword, "vi")))
|| (!(strcasecmp(firstword, editor)))) {
vi_cmd(firstword);
continue;
}
firstword[strlen(firstword)] = firstword_separator;
append_line:
in_comment = update_comment(in_comment, line);
append_line(line);
line = NULL;
}
}
// ran at startup.
static void repairDatabasesAndCheckVersion(bool shouldClearNonLocalTmpCollections) {
// LastError * le = lastError.get( true );
LOG(1) << "enter repairDatabases (to check pdfile version #)" << endl;
Lock::GlobalWrite lk;
DurTransaction txn;
vector< string > dbNames;
getDatabaseNames( dbNames );
for ( vector< string >::iterator i = dbNames.begin(); i != dbNames.end(); ++i ) {
string dbName = *i;
LOG(1) << "\t" << dbName << endl;
Client::Context ctx( dbName );
DataFile *p = ctx.db()->getExtentManager().getFile( 0 );
DataFileHeader *h = p->getHeader();
if ( replSettings.usingReplSets() ) {
// we only care about the _id index if we are in a replset
checkForIdIndexes(ctx.db());
}
if (shouldClearNonLocalTmpCollections || dbName == "local")
ctx.db()->clearTmpCollections(&txn);
if (!h->isCurrentVersion() || mongodGlobalParams.repair) {
if( h->version <= 0 ) {
uasserted(14026,
str::stream() << "db " << dbName << " appears corrupt pdfile version: " << h->version
<< " info: " << h->versionMinor << ' ' << h->fileLength);
}
if ( !h->isCurrentVersion() ) {
log() << "****" << endl;
log() << "****" << endl;
log() << "need to upgrade database " << dbName << " "
<< "with pdfile version " << h->version << "." << h->versionMinor << ", "
<< "new version: "
<< PDFILE_VERSION << "." << PDFILE_VERSION_MINOR_22_AND_OLDER
<< endl;
}
if (mongodGlobalParams.upgrade) {
// QUESTION: Repair even if file format is higher version than code?
doDBUpgrade( dbName, h );
}
else {
log() << "\t Not upgrading, exiting" << endl;
log() << "\t run --upgrade to upgrade dbs, then start again" << endl;
log() << "****" << endl;
dbexit( EXIT_NEED_UPGRADE );
mongodGlobalParams.upgrade = 1;
return;
}
}
else {
const string systemIndexes = ctx.db()->name() + ".system.indexes";
Collection* coll = ctx.db()->getCollection( systemIndexes );
auto_ptr<Runner> runner(InternalPlanner::collectionScan(systemIndexes,coll));
BSONObj index;
Runner::RunnerState state;
while (Runner::RUNNER_ADVANCED == (state = runner->getNext(&index, NULL))) {
const BSONObj key = index.getObjectField("key");
const string plugin = IndexNames::findPluginName(key);
if (h->versionMinor == PDFILE_VERSION_MINOR_22_AND_OLDER) {
if (IndexNames::existedBefore24(plugin))
continue;
log() << "Index " << index << " claims to be of type '" << plugin << "', "
<< "which is either invalid or did not exist before v2.4. "
<< "See the upgrade section: "
<< "http://dochub.mongodb.org/core/upgrade-2.4"
<< startupWarningsLog;
}
const Status keyStatus = validateKeyPattern(key);
if (!keyStatus.isOK()) {
log() << "Problem with index " << index << ": " << keyStatus.reason()
<< " This index can still be used however it cannot be rebuilt."
<< " For more info see"
<< " http://dochub.mongodb.org/core/index-validation"
<< startupWarningsLog;
}
}
if (Runner::RUNNER_EOF != state) {
warning() << "Internal error while reading collection " << systemIndexes;
}
Database::closeDatabase(dbName.c_str(), storageGlobalParams.dbpath);
}
}
LOG(1) << "done repairDatabases" << endl;
if (mongodGlobalParams.upgrade) {
log() << "finished checking dbs" << endl;
cc().shutdown();
dbexit( EXIT_CLEAN );
}
}
int Tool::main( int argc , char ** argv ){
static StaticObserver staticObserver;
cmdLine.prealloc = false;
boost::filesystem::path::default_name_check( boost::filesystem::no_check );
_name = argv[0];
/* using the same style as db.cpp */
int command_line_style = (((po::command_line_style::unix_style ^
po::command_line_style::allow_guessing) |
po::command_line_style::allow_long_disguise) ^
po::command_line_style::allow_sticky);
try {
po::options_description all_options("all options");
all_options.add(*_options).add(*_hidden_options);
po::store( po::command_line_parser( argc , argv ).
options(all_options).
positional( _positonalOptions ).
style(command_line_style).run() , _params );
po::notify( _params );
} catch (po::error &e) {
cerr << "ERROR: " << e.what() << endl << endl;
printHelp(cerr);
return EXIT_BADOPTIONS;
}
// hide password from ps output
for (int i=0; i < (argc-1); ++i){
if (!strcmp(argv[i], "-p") || !strcmp(argv[i], "--password")){
char* arg = argv[i+1];
while (*arg){
*arg++ = 'x';
}
}
}
if ( _params.count( "help" ) ){
printHelp(cout);
return 0;
}
if ( _params.count( "verbose" ) ) {
logLevel = 1;
}
for (string s = "vv"; s.length() <= 10; s.append("v")) {
if (_params.count(s)) {
logLevel = s.length();
}
}
preSetup();
bool useDirectClient = hasParam( "dbpath" );
if ( ! useDirectClient ) {
_host = "127.0.0.1";
if ( _params.count( "host" ) )
_host = _params["host"].as<string>();
if ( _params.count( "port" ) )
_host += ':' + _params["port"].as<string>();
if ( _noconnection ){
// do nothing
}
else {
string errmsg;
ConnectionString cs = ConnectionString::parse( _host , errmsg );
if ( ! cs.isValid() ){
cerr << "invalid hostname [" << _host << "] " << errmsg << endl;
return -1;
}
_conn = cs.connect( errmsg );
if ( ! _conn ){
cerr << "couldn't connect to [" << _host << "] " << errmsg << endl;
return -1;
}
}
(_usesstdout ? cout : cerr ) << "connected to: " << _host << endl;
}
else {
if ( _params.count( "directoryperdb" ) ) {
directoryperdb = true;
}
assert( lastError.get( true ) );
Client::initThread("tools");
_conn = new DBDirectClient();
_host = "DIRECT";
static string myDbpath = getParam( "dbpath" );
dbpath = myDbpath.c_str();
try {
acquirePathLock();
}
catch ( DBException& ){
cerr << endl << "If you are running a mongod on the same "
"path you should connect to that instead of direct data "
"file access" << endl << endl;
dbexit( EXIT_CLEAN );
return -1;
}
theFileAllocator().start();
}
if ( _params.count( "db" ) )
_db = _params["db"].as<string>();
if ( _params.count( "collection" ) )
_coll = _params["collection"].as<string>();
if ( _params.count( "username" ) )
_username = _params["username"].as<string>();
if ( _params.count( "password" )
&& ( _password.empty() ) ) {
_password = askPassword();
}
if (_params.count("ipv6"))
enableIPv6();
int ret = -1;
try {
ret = run();
}
catch ( DBException& e ){
cerr << "assertion: " << e.toString() << endl;
ret = -1;
}
if ( currentClient.get() )
currentClient->shutdown();
if ( useDirectClient )
dbexit( EXIT_CLEAN );
return ret;
}
