示例#1
0
        /// <summary>
        /// Creates new instance of SQLiteVdbe class by compiling a statement
        /// </summary>
        /// <param name="query"></param>
        /// <returns>Vdbe</returns>
        public SQLiteVdbe(SQLiteDatabase db, String query)
        {
            vm = null;

            // prepare and compile
            Sqlite3.sqlite3_prepare_v2(db.Connection(), query, query.Length, ref vm, 0);
        }
        /// <summary>
        /// Creates new instance of SQLiteVdbe class by compiling a statement
        /// </summary>
        /// <param name="query"></param>
        /// <returns>Vdbe</returns>
        public SQLiteVdbe(SQLiteDatabase db, String query)
        {
            vm = null;

            // prepare and compile
            #if NET_35
              Sqlite3.PrepareV2NoTail
            #else
            Sqlite3.sqlite3_prepare_v2
            #endif
            (db.Connection(), query, query.Length, ref vm, 0);
        }
        public IDbStatement Prepare2(IDbHandle db, string query)
        {
            var dbHandle = (DbHandle) db;
            var stmt = new Sqlite3.Vdbe();

            int r = Sqlite3.sqlite3_prepare_v2(dbHandle.InternalDbHandle, query, -1, ref stmt, 0);

            if (r != 0)
            {
                throw SQLiteException.New((Result) r, GetErrmsg(db));
            }
            return new DbStatement(stmt);
        }
示例#4
0
 public static int sqlite3_prepare_v2(
     sqlite3 db,               /* Database handle. */
     string zSql,              /* UTF-8 encoded SQL statement. */
     int nBytes,               /* Length of zSql in bytes. */
     ref sqlite3_stmt ppStmt,  /* OUT: A pointer to the prepared statement */
     ref string pzTail         /* OUT: End of parsed string */
     )
 {
     int rc;
       rc = sqlite3LockAndPrepare( db, zSql, nBytes, 1, null, ref  ppStmt, ref pzTail );
       Debug.Assert( rc == SQLITE_OK || ppStmt == null );  /* VERIFY: F13021 */
       return rc;
 }
示例#5
0
        // private function for reading rows and creating table and columns
        private int ReadNextRow(Vdbe vm, DataTable table)
        {
            int columnCount = table.Columns.Count;
            if(columnCount == 0)
            {
                if((columnCount = ReadColumnNames(vm, table)) == 0)
                    return Sqlite3.SQLITE_ERROR;
            }

            int resultType;
            if((resultType = Sqlite3.sqlite3_step(vm)) == Sqlite3.SQLITE_ROW)
            {
                object[] columnValues = new object[columnCount];

                for(int i = 0; i < columnCount; i++)
                {
                    int columnType = Sqlite3.sqlite3_column_type(vm, i);
                    switch(columnType)
                    {
                        case Sqlite3.SQLITE_INTEGER:
                            {
                                table.Columns[i].DataType = typeof(Int64);
                                columnValues[i] = Sqlite3.sqlite3_column_int(vm, i);
                                break;
                            }
                        case Sqlite3.SQLITE_FLOAT:
                            {
                                table.Columns[i].DataType = typeof(Double);
                                columnValues[i] = Sqlite3.sqlite3_column_double(vm, i);
                                break;
                            }
                        case Sqlite3.SQLITE_TEXT:
                            {
                                table.Columns[i].DataType = typeof(String);
                                columnValues[i] = Sqlite3.sqlite3_column_text(vm, i);
                                break;
                            }
                        case Sqlite3.SQLITE_BLOB:
                            {
                                table.Columns[i].DataType = typeof(Byte[]);
                                columnValues[i] = Sqlite3.sqlite3_column_blob(vm, i);
                                break;
                            }
                        default:
                            {
                                table.Columns[i].DataType = null;
                                columnValues[i] = "";
                                break;
                            }
                    }
                }
                table.Rows.Add(columnValues);
            }
            return resultType;
        }
示例#6
0
        // private function for creating Column Names
        // Return number of colums read
        private int ReadColumnNames(Vdbe vm, DataTable table)
        {
            String columnName = "";
            int columnType = 0;
            // returns number of columns returned by statement
            int columnCount = Sqlite3.sqlite3_column_count(vm);
            object[] columnValues = new object[columnCount];

            try
            {
                // reads columns one by one
                for(int i = 0; i < columnCount; i++)
                {
                    columnName = Sqlite3.sqlite3_column_name(vm, i);
                    columnType = Sqlite3.sqlite3_column_type(vm, i);

                    switch(columnType)
                    {
                        case Sqlite3.SQLITE_INTEGER:
                            {
                                // adds new integer column to table
                                table.Columns.Add(columnName, Type.GetType("System.Int64"));
                                break;
                            }
                        case Sqlite3.SQLITE_FLOAT:
                            {
                                table.Columns.Add(columnName, Type.GetType("System.Double"));
                                break;
                            }
                        case Sqlite3.SQLITE_TEXT:
                            {
                                table.Columns.Add(columnName, Type.GetType("System.String"));
                                break;
                            }
                        case Sqlite3.SQLITE_BLOB:
                            {
                                table.Columns.Add(columnName, Type.GetType("System.byte[]"));
                                break;
                            }
                        default:
                            {
                                table.Columns.Add(columnName, Type.GetType("System.String"));
                                break;
                            }
                    }
                }
            }
            catch
            {
                return 0;
            }
            return table.Columns.Count;
        }
示例#7
0
 /*
 ** 2003 April 6
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
 **
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 **
 *************************************************************************
 ** This file contains code used to implement the VACUUM command.
 **
 ** Most of the code in this file may be omitted by defining the
 ** SQLITE_OMIT_VACUUM macro.
 *************************************************************************
 **  Included in SQLite3 port to C#-SQLite;  2008 Noah B Hart
 **  C#-SQLite is an independent reimplementation of the SQLite software library
 **
 **  SQLITE_SOURCE_ID: 2011-05-19 13:26:54 ed1da510a239ea767a01dc332b667119fa3c908e
 **
 *************************************************************************
 */
 //#include "sqliteInt.h"
 //#include "vdbeInt.h"
 /*
 ** Finalize a prepared statement.  If there was an error, store the
 ** text of the error message in *pzErrMsg.  Return the result code.
 */
 static int vacuumFinalize(sqlite3 db, sqlite3_stmt pStmt, string pzErrMsg)
 {
     int rc;
     rc = sqlite3VdbeFinalize(ref pStmt);
     if (rc != 0)
     {
         sqlite3SetString(ref pzErrMsg, db, sqlite3_errmsg(db));
     }
     return rc;
 }
示例#8
0
 private Sqlite3.Vdbe Prepare(String strStatement, Object[] values)
 {
     Sqlite3.Vdbe ppStmt=new Sqlite3.Vdbe();
     Sqlite3.sqlite3_prepare_v2(m_db, strStatement, strStatement.Length, ref ppStmt, 0);
     checkError();
     
     Bind(ppStmt, values);
     return ppStmt;
 }
示例#9
0
 public CSqliteResult(Sqlite3.Vdbe stmt, boolean bNoCopy)
 {
     m_bNoCopy = bNoCopy;
     m_st = stmt;
 }
示例#10
0
 public void close()
 {
     if (m_st != null)
     {
         Sqlite3.sqlite3_finalize(ref m_st);
         m_st = null;
     }
 }
示例#11
0
        /// <summary>
        /// Converts a USDX 1.01 or CMD 1.01 database to Vocaluxe format
        /// </summary>
        /// <param name="FilePath">Database file path</param>
        /// <returns>True if succeeded</returns>
        private static bool ConvertFrom101(string FilePath)
        {
            SQLiteConnection connection = new SQLiteConnection();
            connection.ConnectionString = "Data Source=" + FilePath;
            SQLiteCommand command;
            SQLiteDataReader reader = null;

            try
            {
                connection.Open();
            }
            catch (Exception)
            {
                return false;
            }

            command = new SQLiteCommand(connection);

            command.CommandText = "PRAGMA table_info(US_Scores);";
            reader = command.ExecuteReader();


            bool dateExists = false;

            //Check for column Date
            while (reader.Read())
            {
                for (int i = 0; i < reader.FieldCount; i++)
                {
                    if (reader.GetName(i) == "name")
                    {
                        if (reader.GetString(i) == "Date")
                            dateExists = true;
                        break;
                    }
                }
            }


            reader.Close();

            //This is a USDX 1.01 DB
            if (!dateExists)
                command.CommandText = "INSERT INTO Scores (SongID, PlayerName, Score, LineNr, Date, Medley, Duet, Difficulty) SELECT SongID, Player, Score, '0', '0', '0', '0', Difficulty from US_Scores";
            else // This is a CMD 1.01 DB
                command.CommandText = "INSERT INTO Scores (SongID, PlayerName, Score, LineNr, Date, Medley, Duet, Difficulty) SELECT SongID, Player, Score, '0', Date, '0', '0', Difficulty from US_Scores";
            command.ExecuteNonQuery();

            command.CommandText = "INSERT INTO Songs SELECT ID, Artist, Title, TimesPlayed from US_Songs";
            command.ExecuteNonQuery();

            // convert from CP1252 to UTF8
            List<SData> scores = new List<SData>();
            List<SData> songs = new List<SData>();

            Sqlite3.sqlite3 OldDB;
            int res = Sqlite3.sqlite3_open(FilePath, out OldDB);

            if (res != Sqlite3.SQLITE_OK)
            {
                CLog.LogError("Error opening Database: " + FilePath + " (" + Sqlite3.sqlite3_errmsg(OldDB) + ")");
            }
            else
            {
                Sqlite3.Vdbe Stmt = new Sqlite3.Vdbe();
                res = Sqlite3.sqlite3_prepare_v2(OldDB, "SELECT id, Artist, Title FROM Songs", -1, ref Stmt, 0);

                if (res != Sqlite3.SQLITE_OK)
                {
                    CLog.LogError("Error query Database: " + FilePath + " (" + Sqlite3.sqlite3_errmsg(OldDB) + ")");
                }
                else
                {
                    //Sqlite3.sqlite3_step(Stmt);

                    Encoding UTF8 = Encoding.UTF8;
                    Encoding CP1252 = Encoding.GetEncoding(1252);

                    while (Sqlite3.sqlite3_step(Stmt) == Sqlite3.SQLITE_ROW)
                    {
                        SData data = new SData();

                        data.id = Sqlite3.sqlite3_column_int(Stmt, 0);

                        byte[] bytes = Sqlite3.sqlite3_column_rawbytes(Stmt, 1);
                        if (bytes != null)
                            data.str1 = UTF8.GetString(Encoding.Convert(CP1252, UTF8, bytes));
                        else
                            data.str1 = "Someone";

                        bytes = Sqlite3.sqlite3_column_rawbytes(Stmt, 2);
                        if (bytes != null)
                            data.str2 = UTF8.GetString(Encoding.Convert(CP1252, UTF8, bytes));
                        else
                            data.str2 = "Someone";

                        songs.Add(data);
                    }
                    Sqlite3.sqlite3_finalize(Stmt);
                }

                Stmt = new Sqlite3.Vdbe();

                if (!dateExists)
                    res = Sqlite3.sqlite3_prepare_v2(OldDB, "SELECT id, PlayerName FROM Scores", -1, ref Stmt, 0);
                else
                    res = Sqlite3.sqlite3_prepare_v2(OldDB, "SELECT id, PlayerName, Date FROM Scores", -1, ref Stmt, 0);

                if (res != Sqlite3.SQLITE_OK)
                {
                    CLog.LogError("Error query Database: " + FilePath + " (" + Sqlite3.sqlite3_errmsg(OldDB) + ")");
                }
                else
                {
                    //Sqlite3.sqlite3_step(Stmt);

                    Encoding UTF8 = Encoding.UTF8;
                    Encoding CP1252 = Encoding.GetEncoding(1252);

                    while (Sqlite3.sqlite3_step(Stmt) == Sqlite3.SQLITE_ROW)
                    {
                        SData data = new SData();

                        data.id = Sqlite3.sqlite3_column_int(Stmt, 0);

                        byte[] bytes = Sqlite3.sqlite3_column_rawbytes(Stmt, 1);
                        if (bytes != null)
                            data.str1 = UTF8.GetString(Encoding.Convert(CP1252, UTF8, bytes));
                        else
                            data.str1 = "Someone";

                        if (dateExists)
                            data.ticks = UnixTimeToTicks(Sqlite3.sqlite3_column_int(Stmt, 2));

                        scores.Add(data);
                    }
                    Sqlite3.sqlite3_finalize(Stmt);
                }
            }
            Sqlite3.sqlite3_close(OldDB);

            SQLiteTransaction _Transaction = connection.BeginTransaction();      
             
            // update Title and Artist strings
            foreach (SData data in songs)
            {
                command.CommandText = "UPDATE Songs SET [Artist] = @artist, [Title] = @title WHERE [ID] = @id";
                command.Parameters.Add("@title", System.Data.DbType.String, 0).Value = data.str2;
                command.Parameters.Add("@artist", System.Data.DbType.String, 0).Value = data.str1;
                command.Parameters.Add("@id", System.Data.DbType.Int32, 0).Value = data.id;
                command.ExecuteNonQuery();
            }           

            // update player names
            foreach (SData data in scores)
            {
                if (!dateExists)
                    command.CommandText = "UPDATE Scores SET [PlayerName] = @player WHERE [id] = @id";
                else
                {
                    command.CommandText = "UPDATE Scores SET [PlayerName] = @player, [Date] = @date WHERE [id] = @id";
                    command.Parameters.Add("@date", System.Data.DbType.Int64, 0).Value = data.ticks;
                }
                command.Parameters.Add("@player", System.Data.DbType.String, 0).Value = data.str1;
                command.Parameters.Add("@id", System.Data.DbType.Int32, 0).Value = data.id;
                command.ExecuteNonQuery();
            }
            _Transaction.Commit();

            //Delete old tables after conversion
            command.CommandText = "DROP TABLE US_Scores;";
            command.ExecuteNonQuery();

            command.CommandText = "DROP TABLE US_Songs;";
            command.ExecuteNonQuery();

            reader.Dispose();
            command.Dispose();
            connection.Close();
            connection.Dispose();

            return true;
        }
示例#12
0
文件: Progresivo.cs 项目: ayeec/evote
 void executeUpdates()
 {
     for (int x = 0; x < ctrPaneles; x++)
     {
         if(!String.IsNullOrEmpty(updates[x])){
         string select = "select votos from candidato where nombre='" + updates[x] + "';";
         Sqlite3.Vdbe pstmt = new Sqlite3.Vdbe();
         Sqlite3.sqlite3_prepare_v2(Program.db, select, select.Length, ref pstmt, 0);
         Sqlite3.sqlite3_step(pstmt);
         string des=Sqlite3.sqlite3_column_text(pstmt, 0);
         int voto = desencriptarint( SoapHexBinary.Parse(des).Value);
         voto++;
         string enc = new SoapHexBinary(encriptarint(voto)).ToString();
         string update = "update candidato set votos='" + enc + "' where nombre='" + updates[x] + "';";
         string error = "";
         if (Sqlite3.sqlite3_exec(Program.db, update, null, null, ref error) != Sqlite3.SQLITE_OK)
         {
             MessageBox.Show(error);
         }
         Sqlite3.sqlite3_finalize(pstmt);
             
         }
     }
 }
示例#13
0
        /*
        ** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
        */
        static int sqlite3Prepare16(
            sqlite3 db,              /* Database handle. */
            string zSql,             /* UTF-15 encoded SQL statement. */
            int nBytes,              /* Length of zSql in bytes. */
            bool saveSqlFlag,         /* True to save SQL text into the sqlite3_stmt */
            ref sqlite3_stmt ppStmt, /* OUT: A pointer to the prepared statement */
            ref string pzTail        /* OUT: End of parsed string */
            )
        {
            /* This function currently works by first transforming the UTF-16
            ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
            ** tricky bit is figuring out the pointer to return in pzTail.
            */
            string zSql8;
            string zTail8 = "";
            int rc = SQLITE_OK;

            assert( ppStmt );
            *ppStmt = 0;
            if( !sqlite3SafetyCheckOk(db) ){
            return SQLITE_MISUSE_BKPT;
            }
            sqlite3_mutex_enter(db.mutex);
            zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE);
            if( zSql8 !=""){
            rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, null, ref ppStmt, ref zTail8);
            }

            if( zTail8 !="" && pzTail !=""){
            /* If sqlite3_prepare returns a tail pointer, we calculate the
            ** equivalent pointer into the UTF-16 string by counting the unicode
            ** characters between zSql8 and zTail8, and then returning a pointer
            ** the same number of characters into the UTF-16 string.
            */
            Debugger.Break (); // TODO --
            //  int chars_parsed = sqlite3Utf8CharLen(zSql8, (int)(zTail8-zSql8));
            //  pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed);
            }
            sqlite3DbFree(db,ref zSql8);
            rc = sqlite3ApiExit(db, rc);
            sqlite3_mutex_leave(db.mutex);
            return rc;
        }
示例#14
0
        /*
        ** Rerun the compilation of a statement after a schema change.
        **
        ** If the statement is successfully recompiled, return SQLITE_OK. Otherwise,
        ** if the statement cannot be recompiled because another connection has
        ** locked the sqlite3_master table, return SQLITE_LOCKED. If any other error
        ** occurs, return SQLITE_SCHEMA.
        */
        static int sqlite3Reprepare( Vdbe p )
        {
            int rc;
              sqlite3_stmt pNew = new sqlite3_stmt();
              string zSql;
              sqlite3 db;

              Debug.Assert( sqlite3_mutex_held( sqlite3VdbeDb( p ).mutex ) );
              zSql = sqlite3_sql( (sqlite3_stmt)p );
              Debug.Assert( zSql != null );  /* Reprepare only called for prepare_v2() statements */
              db = sqlite3VdbeDb( p );
              Debug.Assert( sqlite3_mutex_held( db.mutex ) );
              string dummy = "";
              rc = sqlite3LockAndPrepare( db, zSql, -1, 0, p, ref pNew, ref dummy );
              if ( rc != 0 )
              {
            if ( rc == SQLITE_NOMEM )
            {
              //        db.mallocFailed = 1;
            }
            Debug.Assert( pNew == null );
            return rc;
              }
              else
              {
            Debug.Assert( pNew != null );
              }
              sqlite3VdbeSwap( (Vdbe)pNew, p );
              sqlite3TransferBindings( pNew, (sqlite3_stmt)p );
              sqlite3VdbeResetStepResult( (Vdbe)pNew );
              sqlite3VdbeFinalize( (Vdbe)pNew );
              return SQLITE_OK;
        }
示例#15
0
        /*
        ** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
        */
        static int sqlite3Prepare(
            sqlite3 db,               /* Database handle. */
            string zSql,              /* UTF-8 encoded SQL statement. */
            int nBytes,               /* Length of zSql in bytes. */
            int saveSqlFlag,          /* True to copy SQL text into the sqlite3_stmt */
            Vdbe pReprepare,          /* VM being reprepared */
            ref sqlite3_stmt ppStmt,  /* OUT: A pointer to the prepared statement */
            ref string pzTail         /* OUT: End of parsed string */
            )
        {
            Parse pParse;             /* Parsing context */
              string zErrMsg = "";      /* Error message */
              int rc = SQLITE_OK;       /* Result code */
              int i;                    /* Loop counter */

              /* Allocate the parsing context */
              pParse = new Parse();//sqlite3StackAllocZero(db, sizeof(*pParse));
              if ( pParse == null )
              {
            rc = SQLITE_NOMEM;
            goto end_prepare;
              }
              pParse.pReprepare = pReprepare;
              pParse.sLastToken.z = "";

              Debug.Assert( ppStmt == null );//  assert( ppStmt && *ppStmt==0 );
              //Debug.Assert( 0 == db.mallocFailed );
              Debug.Assert( sqlite3_mutex_held( db.mutex ) );

              /* Check to verify that it is possible to get a read lock on all
              ** database schemas.  The inability to get a read lock indicates that
              ** some other database connection is holding a write-lock, which in
              ** turn means that the other connection has made uncommitted changes
              ** to the schema.
              **
              ** Were we to proceed and prepare the statement against the uncommitted
              ** schema changes and if those schema changes are subsequently rolled
              ** back and different changes are made in their place, then when this
              ** prepared statement goes to run the schema cookie would fail to detect
              ** the schema change.  Disaster would follow.
              **
              ** This thread is currently holding mutexes on all Btrees (because
              ** of the sqlite3BtreeEnterAll() in sqlite3LockAndPrepare()) so it
              ** is not possible for another thread to start a new schema change
              ** while this routine is running.  Hence, we do not need to hold
              ** locks on the schema, we just need to make sure nobody else is
              ** holding them.
              **
              ** Note that setting READ_UNCOMMITTED overrides most lock detection,
              ** but it does *not* override schema lock detection, so this all still
              ** works even if READ_UNCOMMITTED is set.
              */
              for ( i = 0; i < db.nDb; i++ )
              {
            Btree pBt = db.aDb[i].pBt;
            if ( pBt != null )
            {
              Debug.Assert( sqlite3BtreeHoldsMutex( pBt ) );
              rc = sqlite3BtreeSchemaLocked( pBt );
              if ( rc != 0 )
              {
            string zDb = db.aDb[i].zName;
            sqlite3Error( db, rc, "database schema is locked: %s", zDb );
            testcase( db.flags & SQLITE_ReadUncommitted );
            goto end_prepare;
              }
            }
              }

              sqlite3VtabUnlockList( db );

              pParse.db = db;
              pParse.nQueryLoop = (double)1;
              if ( nBytes >= 0 && ( nBytes == 0 || zSql[nBytes - 1] != 0 ) )
              {
            string zSqlCopy;
            int mxLen = db.aLimit[SQLITE_LIMIT_SQL_LENGTH];
            testcase( nBytes == mxLen );
            testcase( nBytes == mxLen + 1 );
            if ( nBytes > mxLen )
            {
              sqlite3Error( db, SQLITE_TOOBIG, "statement too long" );
              rc = sqlite3ApiExit( db, SQLITE_TOOBIG );
              goto end_prepare;
            }
            zSqlCopy = zSql.Substring( 0, nBytes );// sqlite3DbStrNDup(db, zSql, nBytes);
            if ( zSqlCopy != null )
            {
              sqlite3RunParser( pParse, zSqlCopy, ref zErrMsg );
              sqlite3DbFree( db, ref zSqlCopy );
              //pParse->zTail = &zSql[pParse->zTail-zSqlCopy];
            }
            else
            {
              //pParse->zTail = &zSql[nBytes];
            }
              }
              else
              {
            sqlite3RunParser( pParse, zSql, ref zErrMsg );
              }
              Debug.Assert( 1 == (int)pParse.nQueryLoop );

              //if ( db.mallocFailed != 0 )
              //{
              //  pParse.rc = SQLITE_NOMEM;
              //}
              if ( pParse.rc == SQLITE_DONE )
            pParse.rc = SQLITE_OK;
              if ( pParse.checkSchema != 0 )
              {
            schemaIsValid( pParse );
              }
              if ( pParse.rc == SQLITE_SCHEMA )
              {
            sqlite3ResetInternalSchema( db, 0 );
              }
              //if ( db.mallocFailed != 0 )
              //{
              //  pParse.rc = SQLITE_NOMEM;
              //}
              //if (pzTail != null)
              {
            pzTail = pParse.zTail == null ? "" : pParse.zTail.ToString();
              }
              rc = pParse.rc;
            #if !SQLITE_OMIT_EXPLAIN
              if ( rc == SQLITE_OK && pParse.pVdbe != null && pParse.explain != 0 )
              {
            string[] azColName = new string[] {
            "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment",
            "selectid", "order", "from", "detail"
            };
            int iFirst, mx;
            if ( pParse.explain == 2 )
            {
              sqlite3VdbeSetNumCols( pParse.pVdbe, 4 );
              iFirst = 8;
              mx = 12;
            }
            else
            {
              sqlite3VdbeSetNumCols( pParse.pVdbe, 8 );
              iFirst = 0;
              mx = 8;
            }
            for ( i = iFirst; i < mx; i++ )
            {
              sqlite3VdbeSetColName( pParse.pVdbe, i - iFirst, COLNAME_NAME,
              azColName[i], SQLITE_STATIC );
            }
              }
            #endif

              Debug.Assert( db.init.busy == 0 || saveSqlFlag == 0 );
              if ( db.init.busy == 0 )
              {
            Vdbe pVdbe = pParse.pVdbe;
            sqlite3VdbeSetSql( pVdbe, zSql, (int)( zSql.Length - ( pParse.zTail == null ? 0 : pParse.zTail.Length ) ), saveSqlFlag );
              }
              if ( pParse.pVdbe != null && ( rc != SQLITE_OK /*|| db.mallocFailed != 0 */ ) )
              {
            sqlite3VdbeFinalize( pParse.pVdbe );
            Debug.Assert( ppStmt == null );
              }
              else
              {
            ppStmt = pParse.pVdbe;
              }

              if ( zErrMsg != "" )
              {
            sqlite3Error( db, rc, "%s", zErrMsg );
            sqlite3DbFree( db, ref zErrMsg );
              }
              else
              {
            sqlite3Error( db, rc, 0 );
              }

              /* Delete any TriggerPrg structures allocated while parsing this statement. */
              while ( pParse.pTriggerPrg != null )
              {
            TriggerPrg pT = pParse.pTriggerPrg;
            pParse.pTriggerPrg = pT.pNext;
            sqlite3DbFree( db, ref pT );
              }

            end_prepare:

              //sqlite3StackFree( db, pParse );
              rc = sqlite3ApiExit( db, rc );
              Debug.Assert( ( rc & db.errMask ) == rc );
              return rc;
        }
示例#16
0
 static int sqlite3LockAndPrepare(
     sqlite3 db,               /* Database handle. */
     string zSql,              /* UTF-8 encoded SQL statement. */
     int nBytes,               /* Length of zSql in bytes. */
     int saveSqlFlag,          /* True to copy SQL text into the sqlite3_stmt */
     Vdbe pOld,                /* VM being reprepared */
     ref sqlite3_stmt ppStmt,  /* OUT: A pointer to the prepared statement */
     ref string pzTail         /* OUT: End of parsed string */
     )
 {
     int rc;
       //  assert( ppStmt!=0 );
       ppStmt = null;
       if ( !sqlite3SafetyCheckOk( db ) )
       {
     return SQLITE_MISUSE_BKPT();
       }
       sqlite3_mutex_enter( db.mutex );
       sqlite3BtreeEnterAll( db );
       rc = sqlite3Prepare( db, zSql, nBytes, saveSqlFlag, pOld, ref ppStmt, ref pzTail );
       if ( rc == SQLITE_SCHEMA )
       {
     sqlite3_finalize( ppStmt );
     rc = sqlite3Prepare( db, zSql, nBytes, saveSqlFlag, pOld, ref ppStmt, ref  pzTail );
       }
       sqlite3BtreeLeaveAll( db );
       sqlite3_mutex_leave( db.mutex );
       return rc;
 }