int main_()
{
printf("%d\n", sqlite3_complete("select * from emp;")); // output 1
printf("%d\n", sqlite3_complete(";")); // output 1
printf("%d\n", sqlite3_complete("f**k you;")); // output 1
printf("%d\n", sqlite3_complete("select * from emp")); // output 0
printf("%d\n", sqlite3_complete("select * from emp\0;")); // output 0
return 0;
}
/* call-seq: complete?(sql)
*
* Return +true+ if the string is a valid (ie, parsable) SQL statement, and
* +false+ otherwise.
*/
static VALUE complete_p(VALUE UNUSED(self), VALUE sql)
{
if(sqlite3_complete(StringValuePtr(sql)))
return Qtrue;
return Qfalse;
}
/**
@SYMTestCaseID SYSLIB-SQLITE3-UT-4002
@SYMTestCaseDesc Statement handle SQLITE3 tests.
List of called SQLITE3 functions:
- sqlite3_complete;
- sqlite3_complete16;
- sqlite3_prepare;
- sqlite3_finalize;
- sqlite3_column_count;
- sqlite3_db_handle;
- sqlite3_step;
- sqlite3_column_decltype;
- sqlite3_column_decltype16;
- sqlite3_column_name;
- sqlite3_column_name16;
- sqlite3_column_int;
- sqlite3_column_int64;
- sqlite3_column_double;
- sqlite3_column_text;
- sqlite3_column_text16;
- sqlite3_column_blob;
@SYMTestPriority High
@SYMTestActions Statement handle SQLITE3 tests.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ8782
*/
static void TestStatement1()
{
const char* tail = 0;
int err;
TEST(TheDb != 0);
TEST(!TheStmt);
err = sqlite3_complete("SELECT * FROM A;");
TEST(err != 0);
err = sqlite3_complete16(L"SELECT * FROM A;");
TEST(err != 0);
err = sqlite3_prepare(TheDb, "SELECT * FROM A", -1, &TheStmt, &tail);
TEST2(err, SQLITE_OK);
TEST((unsigned int)TheStmt);
TEST(!tail || strlen(tail) == 0);
DoTestStatement();
err = sqlite3_finalize(TheStmt);
TEST2(err, SQLITE_OK);
TheStmt = 0;
}
int main2()
{
sqlite3 *db;
int rc;
rc = sqlite3_open("./employees.db", &db);
if( rc != SQLITE_OK )
{
fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
sqlite3_close(db);
return(1);
}
int cols;
sqlite3_stmt *stmt;
const char* tail = NULL;
//const char* sql = "create table emp(id, name);select * from emp;";
const char* sql = "select * from emp;select * from emp where name like 'm%';";
while (sqlite3_complete(sql))
{
printf("sql = %s\n", sql);
rc = sqlite3_prepare_v2(db, sql, -1, &stmt, &tail);
printf("after sqlite3_prepare_v2() called, rc = %d, tail = |%s|, tail = %p, *tail = %d\n", rc, tail, tail, *tail);
if( rc != SQLITE_OK )
{
fprintf(stderr, "SQL error: %s\n", sqlite3_errmsg(db));
}
cols = sqlite3_column_count(stmt);
rc = sqlite3_step(stmt);
while(rc == SQLITE_ROW)
{
int i;
for (i = 0; i < cols; i++)
{
printf("%s ", sqlite3_column_text(stmt, i));
}
printf("\n");
rc = sqlite3_step(stmt);
}
if (sql == tail)
{
printf("please check you sql!\n");
break;
}
else
{
sql = tail;
}
printf("\n\n");
}
sqlite3_finalize(stmt);
sqlite3_close(db);
return 0;
}
static void process_input(sqlite3 * db, FILE *in, int * lineErr){
char *zLine;
char *zSql = 0;
char * zErrMsg = 0;
int nSql = 0;
int rc;
while((zLine = sqlbrowser_getline(in))!=0 ){
if( (zSql==0 || zSql[0]==0) && _all_whitespace(zLine) ) continue;
(*lineErr)++;
if( zSql==0 ){
int i;
for(i=0; zLine[i] && isspace(zLine[i]); i++){}
if( zLine[i]!=0 ){
nSql = strlen(zLine);
zSql = malloc( nSql+1 );
strcpy(zSql, zLine);
}
}else{
int len = strlen(zLine);
zSql = realloc( zSql, nSql + len + 2 );
/*if( zSql==0 ){
fprintf(stderr,"%s: out of memory!\n", Argv0);
exit(1);
}*/
strcpy(&zSql[nSql++], "\n");
strcpy(&zSql[nSql], zLine);
nSql += len;
}
free(zLine);
if( zSql && _ends_with_semicolon(zSql, nSql) && sqlite3_complete(zSql) ){
rc = sqlite3_exec(db, zSql, NULL, NULL, &zErrMsg);//&zErrMsg
if( rc || zErrMsg ){
//if( in!=0 && !p->echoOn ) printf("%s\n",zSql);
if( zErrMsg!=0 ){
/*printf("SQL error: %s\n", zErrMsg);*/
free(zErrMsg);
zErrMsg = 0;
if( zSql ){
free(zSql);
}
return;
}/*else{
printf("SQL error: %s\n", sqlite3_error_string(rc));
}*/
}
free(zSql);
zSql = 0;
nSql = 0;
}
}
if( zSql ){
/*if( !_all_whitespace(zSql) ) printf("Incomplete SQL: %s\n", zSql);*/
free(zSql);
}
/*normal exit, clear err*/
*lineErr = 0;
}
/*
** Return true if zSql is a complete SQL statement. Return false if it
** ends in the middle of a string literal or C-style comment.
*/
static int _is_complete(char *zSql, int nSql){
int rc;
if( zSql==0 ) return 1;
zSql[nSql] = ';';
zSql[nSql+1] = 0;
rc = sqlite3_complete(zSql);
zSql[nSql] = 0;
return rc;
}
ikptr
ik_sqlite3_complete (ikptr s_sql_snippet)
{
#ifdef HAVE_SQLITE3_COMPLETE
const char * sql_snippet = IK_CHARP_FROM_BYTEVECTOR_OR_POINTER_OR_MBLOCK(s_sql_snippet);
return (sqlite3_complete(sql_snippet))? IK_TRUE_OBJECT : IK_FALSE_OBJECT;
#else
feature_failure(__func__);
#endif
}
/*
** This routine is the same as the sqlite3_complete() routine described
** above, except that the parameter is required to be UTF-16 encoded, not
** UTF-8.
*/
int sqlite3_complete16(const void *zSql){
sqlite3_value *pVal;
char const *zSql8;
int rc = 0;
pVal = sqlite3ValueNew();
sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);
zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);
if( zSql8 ){
rc = sqlite3_complete(zSql8);
}
sqlite3ValueFree(pVal);
return rc;
}
SWIGEXPORT jint JNICALL Java_com_almworks_sqlite4java__1SQLiteSwiggedJNI_sqlite3_1complete(JNIEnv *jenv, jclass jcls, jstring jarg1) {
jint jresult = 0 ;
char *arg1 = (char *) 0 ;
int result;
(void)jenv;
(void)jcls;
arg1 = 0;
if (jarg1) {
arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
if (!arg1) return 0;
}
result = (int)sqlite3_complete((char const *)arg1);
jresult = (jint)result;
if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
return jresult;
}
/*
** This routine is the same as the sqlite3_complete() routine described
** above, except that the parameter is required to be UTF-16 encoded, not
** UTF-8.
*/
int sqlite3_complete16(const void *zSql){
sqlite3_value *pVal;
char const *zSql8;
int rc = SQLITE_NOMEM;
#ifndef SQLITE_OMIT_AUTOINIT
rc = sqlite3_initialize();
if( rc ) return rc;
#endif
pVal = sqlite3ValueNew(0);
sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);
zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);
if( zSql8 ){
rc = sqlite3_complete(zSql8);
}else{
rc = SQLITE_NOMEM;
}
sqlite3ValueFree(pVal);
return sqlite3ApiExit(0, rc);
}
static PyObject* module_complete(PyObject* self, PyObject* args, PyObject*
kwargs)
{
static char *kwlist[] = {"statement", NULL, NULL};
char* statement;
PyObject* result;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s", kwlist, &statement))
{
return NULL;
}
if (sqlite3_complete(statement)) {
result = Py_True;
} else {
result = Py_False;
}
Py_INCREF(result);
return result;
}
// read file
int database_loadFile ( database_state_t *pState, const char * pFileName )
{
// local variables
sqlite3 * database = pState->database;
FILE * file = fopen ( pFileName, "rb" );
int result;
if ( file == 0 )
{
error ( "SQL file failed to load!" );
return 1;
}
else
{
char * errorMessage;
char buffer [ DATABASE_FILE_BUFFER_SIZE ];
char * line;
int offset;
int size;
offset = 0;
line = &buffer [ offset ];
size = sizeof ( buffer ) - offset;
while ( NULL != fgets ( line, size, file ) )
{
switch ( sqlite3_complete ( buffer ) )
{
// SQLite3 memory allocation failed
case SQLITE_NOMEM:
error ( "No memory! SQL file failed to load!" );
fclose ( file );
return 1;
break;
// incomplete statement, append next line
case 0:
if ( '-' == line[ 0 ] && '-' == line[ 1 ] )
{
// comment, ignore line
// this comment detection is not robust!
}
else
{
// read next line
offset = strlen ( buffer );
}
break;
// complete statement, execute SQL and reset offset
default:
if ( SQLITE_OK != sqlite3_exec ( database, buffer, NULL, NULL, &errorMessage ) )
{
error ( errorMessage );
sqlite3_free ( errorMessage );
}
offset = 0;
break;
}
// update based on offset
line = &buffer [ offset ];
size = sizeof ( buffer ) - offset;
if ( size <= 1 )
{
error ( "Buffer too small! SQL file failed to load!" );
fclose ( file );
return 1;
}
}
fclose ( file );
}
return result;
}
/*
* This ist the Entry Function of this Mex-DLL
*/
void mexFunction(int nlhs, mxArray*plhs[], int nrhs, const mxArray*prhs[])
{
mexAtExit(CloseDBs);
/*
* Get the current Language
*/
if (Language == -1)
{
#ifdef _WIN32
switch(PRIMARYLANGID(GetUserDefaultLangID()))
{
case LANG_GERMAN:
Language = 1;
break;
default:
Language = 0;
}
#else
Language = 0;
#endif
}
/*
* Print Version Information
*/
if (! FirstStart)
{
FirstStart = true;
mexPrintf (MSG_HELLO, sqlite3_libversion());
}
/*
* Check if the first argument is a number, then we have to use
* this number as an database id.
*/
int db_id = 0;
int FirstArg = 0;
int NumArgs = nrhs;
if (nrhs >= 1 && mxIsNumeric(prhs[0]))
{
db_id = (int) *mxGetPr(prhs[0]);
if (db_id < 0 || db_id > MaxNumOfDbs)
{
mexPrintf(MSG_INVALIDDBHANDLE);
mexErrMsgTxt(MSG_IMPOSSIBLE);
}
db_id --;
FirstArg ++;
NumArgs --;
}
/*
* All remaining arguments have to be strings
*/
bool isNotOK = false;
int i;
for (i = FirstArg; i < nrhs; i++)
{
if (! mxIsChar(prhs[i]))
{
isNotOK = true;
break;
}
}
if (NumArgs < 1 || isNotOK)
{
mexPrintf(MSG_USAGE);
mexErrMsgTxt(MSG_INVALIDARG);
}
/*
* Get the first string argument, this is the command string
*/
char *command = getstring(prhs[FirstArg]);
if (! strcmp(command, "open"))
{
/*
* open a database. There have to be two string arguments.
* The command 'open' and the database filename
*/
if (NumArgs != 2)
{
mexPrintf(MSG_NOOPENARG, mexFunctionName());
mxFree(command);
mexErrMsgTxt(MSG_INVALIDARG);
}
// TODO: Memoryleak 'command not freed' when getstring fails
char* dbname = getstring(prhs[FirstArg +1]);
/*
* Is there an database ID? The close the database with the same id
*/
if (db_id > 0 && g_dbs[db_id])
{
sqlite3_close(g_dbs[db_id]);
g_dbs[db_id] = 0;
}
/*
* If there isn't an database id, then try to get one
*/
if (db_id < 0)
{
for (i = 0; i < MaxNumOfDbs; i++)
{
if (g_dbs[i] == 0)
{
db_id = i;
break;
}
}
}
/*
* no database id? sorry, database id table full
*/
if (db_id < 0)
{
plhs[0] = mxCreateScalarDouble((double) 0);
mexPrintf(MSG_NOFREESLOT);
mxFree(command);
mxFree(dbname);
mexErrMsgTxt(MSG_IMPOSSIBLE);
}
/*
* Open the database
*/
int rc = sqlite3_open(dbname, &g_dbs[db_id]);
if (rc)
{
/*
* Anything wrong? free the database id and inform the user
*/
mexPrintf(MSG_CANTOPEN, sqlite3_errmsg(g_dbs[db_id]));
sqlite3_close(g_dbs[db_id]);
g_dbs[db_id] = 0;
plhs[0] = mxCreateScalarDouble((double) 0);
mxFree(command);
mxFree(dbname);
mexErrMsgTxt(MSG_IMPOSSIBLE);
}
/*
* return value will be the used database id
*/
plhs[0] = mxCreateScalarDouble((double) db_id +1);
mxFree(dbname);
}
else if (! strcmp(command, "close"))
{
/*
* close a database
*/
/*
* if the database id is < 0 than close all open databases
*/
if (db_id < 0)
{
for (i = 0; i < MaxNumOfDbs; i++)
{
if (g_dbs[i])
{
sqlite3_close(g_dbs[i]);
g_dbs[i] = 0;
}
}
}
else
{
/*
* If the database is open, then close it. Otherwise
* inform the user
*/
if (! g_dbs[db_id])
{
mxFree(command);
mexErrMsgTxt(MSG_DBNOTOPEN);
}
else
{
sqlite3_close(g_dbs[db_id]);
g_dbs[db_id] = 0;
}
}
}
else if (! strcmp(command, "status"))
{
for (i = 0; i < MaxNumOfDbs; i++)
{
mexPrintf("DB Handle %d: %s\n", i, g_dbs[i] ? "OPEN" : "CLOSED");
}
}
else
{
/*
* Every unknown command is treated as an sql query string
*/
/*
* database id < 0? Thats an error...
*/
if (db_id < 0)
{
mexPrintf(MSG_INVALIDDBHANDLE);
mxFree(command);
mexErrMsgTxt(MSG_IMPOSSIBLE);
}
/*
* database not open? -> error
*/
if (!g_dbs[db_id])
{
mxFree(command);
mexErrMsgTxt(MSG_DBNOTOPEN);
}
const char* query = command;
/*
* emulate the "show tables" sql query
*/
if (! strcmpi(query, "show tables"))
{
query = "SELECT name as tablename FROM sqlite_master "
"WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%' "
"UNION ALL "
"SELECT name as tablename FROM sqlite_temp_master "
"WHERE type IN ('table','view') "
"ORDER BY 1";
}
/*
* complete the query
*/
if (sqlite3_complete(query))
{
mxFree(command);
mexErrMsgTxt(MSG_INVQUERY);
}
sqlite3_stmt *st;
/*
* and prepare it
* if anything is wrong with the query, than complain about it.
*/
if (sqlite3_prepare_v2(g_dbs[db_id], query, -1, &st, 0))
{
if (st)
sqlite3_finalize(st);
mxFree(command);
mexErrMsgIdAndTxt(TransErrToIdent(g_dbs[db_id]), sqlite3_errmsg(g_dbs[db_id]));
}
/*
* Any results?
*/
int ncol = sqlite3_column_count(st);
if (ncol > 0)
{
char **fieldnames = new char *[ncol]; /* Column names */
Values* allrows = 0; /* All query results */
Values* lastrow = 0; /* pointer to the last result row */
int rowcount = 0; /* number of result rows */
/*
* Get the column names of the result set
*/
for(i=0; i<ncol; i++)
{
const char *cname = sqlite3_column_name(st, i);
fieldnames[i] = new char [strlen(cname) +1];
strcpy (fieldnames[i], cname);
/*
* replace invalid chars by '_', so we can build
* valid MATLAB structs
*/
char *mk_c = fieldnames[i];
while (*mk_c)
{
if ((*mk_c == ' ') || (*mk_c == '*') || (*mk_c == '?'))
*mk_c = '_';
mk_c++;
}
}
/*
* get the result rows from the engine
*
* We cannot get the number of result lines, so we must
* read them in a loop and save them into an temporary list.
* Later, we can transfer this List into an MATLAB array of structs.
* This way, we must allocate enough memory for two result sets,
* but we save time by allocating the MATLAB Array at once.
*/
for(;;)
{
/*
* Advance to teh next row
*/
int step_res = sqlite3_step(st);
/*
* no row left? break out of the loop
*/
if (step_res != SQLITE_ROW)
break;
/*
* get new memory for the result
*/
Values* RecordValues = new Values(ncol);
Value *v = RecordValues->m_Values;
for (int j = 0; j < ncol; j++, v++)
{
int fieldtype = sqlite3_column_type(st,j);
v->m_Type = fieldtype;
switch (fieldtype)
{
case SQLITE_NULL: v->m_NumericValue = g_NaN; break;
case SQLITE_INTEGER: v->m_NumericValue = (double) sqlite3_column_int(st, j); break;
case SQLITE_FLOAT: v->m_NumericValue = (double) sqlite3_column_double(st, j); break;
case SQLITE_TEXT: v->m_StringValue = strnewdup((const char*) sqlite3_column_text(st, j)); break;
default:
mxFree(command);
mexErrMsgTxt(MSG_UNKNWNDBTYPE);
}
}
/*
* and add this row to the list of all result rows
*/
if (! lastrow)
{
allrows = lastrow = RecordValues;
}
else
{
lastrow->m_NextValues = RecordValues;
lastrow = lastrow->m_NextValues;
}
/*
* we have one more...
*/
rowcount ++;
}
/*
* end the sql engine
*/
sqlite3_finalize(st);
/*
* got nothing? return an empty result to MATLAB
*/
if (rowcount == 0 || ! allrows)
{
if (!( plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL) ))
{
mxFree(command);
mexErrMsgTxt(MSG_CANTCREATEOUTPUT);
}
}
else
{
/*
* Allocate an array of MATLAB structs to return as result
*/
int ndims[2];
ndims[0] = rowcount;
ndims[1] = 1;
if (( plhs[0] = mxCreateStructArray (2, ndims, ncol, (const char**)fieldnames)) == 0)
{
mxFree(command);
mexErrMsgTxt(MSG_CANTCREATEOUTPUT);
}
/*
* transfer the result rows from the temporary list into the result array
*/
lastrow = allrows;
i = 0;
while(lastrow)
{
Value* recordvalue = lastrow->m_Values;
for (int j = 0; j < ncol; j++, recordvalue++)
{
if (recordvalue -> m_Type == SQLITE_TEXT)
{
mxArray* c = mxCreateString(recordvalue->m_StringValue);
mxSetFieldByNumber(plhs[0], i, j, c);
}
else if (recordvalue -> m_Type == SQLITE_NULL && !NULLasNaN)
{
mxArray* out_double = mxCreateDoubleMatrix(0,0,mxREAL);
mxSetFieldByNumber(plhs[0], i, j, out_double);
}
else
{
mxArray* out_double = mxCreateDoubleScalar(recordvalue->m_NumericValue);
mxSetFieldByNumber(plhs[0], i, j, out_double);
}
}
allrows = lastrow;
lastrow = lastrow->m_NextValues;
delete allrows;
i++;
}
}
for(int i=0; i<ncol; i++)
delete [] fieldnames[i];
delete [] fieldnames;
}
else
{
/*
* no result, cleanup the sqlite engine
*/
int res = sqlite3_step(st);
sqlite3_finalize(st);
if (res != SQLITE_DONE)
{
mxFree(command);
mexErrMsgIdAndTxt(TransErrToIdent(g_dbs[db_id]), sqlite3_errmsg(g_dbs[db_id]));
}
}
}
mxFree(command);
}
DLL_FUNCTION(int32_t) BU_SQLite_Complete(const char* sql) {
#pragma comment(linker, "/EXPORT:BU_SQLite_Complete=_BU_SQLite_Complete@4")
return sqlite3_complete(sql);
}
int sqlite3_complete_idr(const char *sql){
int rc = sqlite3_complete(sql);
return rc;
}
__declspec(dllexport) int WINAPI sqlite3_complete_interop(const char *sql)
{
return sqlite3_complete(sql);
}
int main(int argc, char *argv[]) {
sqlite3 *db = NULL;
sqlite3_stmt *stmt = NULL;
int res = 0;
int flags = SQLITE_OPEN_READONLY;
const char *colnms[4] = {NULL}; // Nomi delle colonne
const char *tail = NULL;
const char *sql_str =
"SELECT * FROM addressbook ORDER by id;"
"SELECT * FROM addressbook ORDER by fullname;"
"SELECT * FROM addressbook ORDER by alias;"
"SELECT * FROM addressbook ORDER by email;";
if (argc != 2) {
fprintf(stderr, "Usage: %s <database name>\n", argv[0]);
exit(EXIT_FAILURE);
}
// Inizializzazione della libreria
if (sqlite3_initialize() != SQLITE_OK) {
fprintf(stderr, "Err. Unable to initialize the library.\n");
exit(EXIT_FAILURE);
}
/* Creazione della connessione al database */
res = sqlite3_open_v2(argv[1], &db, flags, NULL);
if (res != SQLITE_OK) {
fprintf(stderr, "Err. can't open database: %s\n", sqlite3_errmsg(db));
sqlite3_close(db);
exit(EXIT_FAILURE);
}
/* Si utilizza la funzione sqlite3_complete() per la verifica della query,
si basa essenzialmente sul riconoscimento del punto e virgola - semicolon -
finale */
while(sqlite3_complete(sql_str)) {
if (sqlite3_prepare_v2(db, sql_str,-1, &stmt, &tail) != SQLITE_OK) {
fprintf(stderr, "Err. Unable to create Prepared Statement.\n");
exit(EXIT_FAILURE);
}
// Stampa il nome di ciascuna colonna.
for (int i=0; i<sqlite3_column_count(stmt); i++)
colnms[i] = sqlite3_column_name(stmt, i);
printf("%2s %10s %8s %14s\n", \
colnms[0], colnms[1], colnms[2], colnms[3]);
// Estrazione dei dati riga per riga
while (sqlite3_step(stmt) == SQLITE_ROW) {
printf("%2d %10s %5s %20s (byte: %3d)\n", \
sqlite3_column_int(stmt, 0), \
(const char*)sqlite3_column_text(stmt, 1), \
(const char*)sqlite3_column_text(stmt, 2), \
(const char*)sqlite3_column_text(stmt, 3), \
sqlite3_column_bytes(stmt, 3));
}
puts("\n");
// L'istruzione successiva da eseguire e' conservata in 'tail'
sql_str = tail;
}
// Rilascio delle risorse relative alla Prepared Statement
if (sqlite3_finalize(stmt) != SQLITE_OK) {
fprintf(stderr, "Err. Unable to finalize.\n");
exit(EXIT_FAILURE);
}
// Close database connection
if (sqlite3_close_v2(db) != SQLITE_OK) {
fprintf(stderr, "Err. Unable to close connection.\n");
exit(EXIT_FAILURE);
}
// Rilascio delle risorse di inizializzazione
sqlite3_shutdown();
return(EXIT_SUCCESS);
}
int Database::IsSQLComplete( LPCTSTR strSQL )
{
return sqlite3_complete( UTF8MBSTR(strSQL) );
}
/*
** Read input from *in and process it. If *in==0 then input
** is interactive - the user is typing it it. Otherwise, input
** is coming from a file or device. A prompt is issued and history
** is saved only if input is interactive. An interrupt signal will
** cause this routine to exit immediately, unless input is interactive.
**
** Return the number of errors.
*/
static int process_input(struct callback_data *p, FILE *in){
char *zLine = 0;
char *zSql = 0;
int nSql = 0;
int nSqlPrior = 0;
char *zErrMsg;
int rc;
int errCnt = 0;
int lineno = 0;
int startline = 0;
while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
//fflush(p->out);
free(zLine);
zLine = one_input_line(in);
if( zLine==0 ){
break; /* We have reached EOF */
}
if( seenInterrupt ){
if( in!=0 ) break;
seenInterrupt = 0;
}
lineno++;
if( (zSql==0 || zSql[0]==0) && _all_whitespace(zLine) ) continue;
if( zLine && zLine[0]=='.' && nSql==0 ){
continue;
}
if( _is_command_terminator(zLine) && _is_complete(zSql, nSql) ){
memcpy(zLine,";",2);
}
nSqlPrior = nSql;
if( zSql==0 ){
int i;
for(i=0; zLine[i] && isspace((unsigned char)zLine[i]); i++){}
if( zLine[i]!=0 ){
nSql = strlen30(zLine);
zSql = (char*)malloc( nSql+3 );
if( zSql==0 ){
fprintf(stderr, "Error: out of memory\n");
exit(1);
}
memcpy(zSql, zLine, nSql+1);
startline = lineno;
}
}else{
int len = strlen30(zLine);
zSql = (char*)realloc( zSql, nSql + len + 4 );
if( zSql==0 ){
fprintf(stderr,"Error: out of memory\n");
exit(1);
}
zSql[nSql++] = '\n';
memcpy(&zSql[nSql], zLine, len+1);
nSql += len;
}
if( zSql && _contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
&& sqlite3_complete(zSql) ){
p->cnt = 0;
//
rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
if( rc || zErrMsg ){
char zPrefix[100];
if( in!=0 || !stdin_is_interactive ){
sqlite3_snprintf(sizeof(zPrefix), zPrefix,
"Error: near line %d:", startline);
}else{
sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
}
if( zErrMsg!=0 ){
fprintf(stderr, "%s %s\n", zPrefix, zErrMsg);
sqlite3_free(zErrMsg);
zErrMsg = 0;
}else{
fprintf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
}
errCnt++;
}
free(zSql);
zSql = 0;
nSql = 0;
}
}
if( zSql ){
if( !_all_whitespace(zSql) ){
fprintf(stderr, "Error: incomplete SQL: %s\n", zSql);
}
free(zSql);
}
free(zLine);
return errCnt;
}
