Beispiel #1
0
        private void GetNextStatement(string pzStart, ref string pzTail, ref csSQLite.Vdbe pStmt)
        {
            //if (parent_conn.Version == 3)
            //{
            UTF8Encoding encoding = new UTF8Encoding();
            SqliteError  err      = (SqliteError)csSQLite.sqlite3_prepare(parent_conn.Handle2, pzStart, encoding.GetBytes(pzStart).Length, ref pStmt, ref pzTail);

            //SqliteError err = (SqliteError)csSQLite.sqlite3_prepare(parent_conn.Handle2, pzStart, encoding.GetBytes(pzStart).Length, ref pStmt, ref pzTail);
            //SqliteError err = Sqlite.sqlite3_prepare16 (parent_conn.Handle, pzStart, -1, out pStmt, out pzTail);
            if (err != SqliteError.OK)
            {
                throw new SqliteSyntaxException(GetError3());
            }

            /*
             * }
             * else
             * {
             *      IntPtr errMsg;
             *      SqliteError err = Sqlite.sqlite_compile (parent_conn.Handle, pzStart, out pzTail, out pStmt, out errMsg);
             *
             *      if (err != SqliteError.OK)
             *      {
             *              string msg = "unknown error";
             *              if (errMsg != IntPtr.Zero)
             *              {
             *                      msg = Marshal.PtrToStringAnsi (errMsg);
             *                      Sqlite.sqliteFree (errMsg);
             *              }
             *              throw new SqliteSyntaxException (msg);
             *      }
             * } */
        }
Beispiel #2
0
        private void GetNextStatement(IntPtr pzStart, out IntPtr pzTail, out IntPtr pStmt)
        {
            if (parent_conn.Version == 3)
            {
                SqliteError err = Sqlite.sqlite3_prepare16(parent_conn.Handle, pzStart, -1, out pStmt, out pzTail);
                if (err != SqliteError.OK)
                {
                    throw new SqliteSyntaxException(GetError3());
                }
            }
            else
            {
                IntPtr      errMsg;
                SqliteError err = Sqlite.sqlite_compile(parent_conn.Handle, pzStart, out pzTail, out pStmt, out errMsg);

                if (err != SqliteError.OK)
                {
                    string msg = "unknown error";
                    if (errMsg != IntPtr.Zero)
                    {
                        msg = Marshal.PtrToStringAnsi(errMsg);
                        Sqlite.sqliteFree(errMsg);
                    }
                    throw new SqliteSyntaxException(msg);
                }
            }
        }
        private void GetNextStatement(string pzStart, ref string pzTail, ref Sqlite3.Vdbe pStmt)
        {
            SqliteError err = (SqliteError)Sqlite3.sqlite3_prepare_v2(parent_conn.Handle2, pzStart, pzStart.Length, ref pStmt, ref pzTail);

            if (err != SqliteError.OK)
            {
                throw new SqliteSyntaxException(parent_conn.Handle2.errCode, GetError3());
            }
        }
        private void GetNextStatement(string pzStart, ref string pzTail, ref Sqlite3.Vdbe pStmt)
        {
            UTF8Encoding encoding = new UTF8Encoding();
            SqliteError  err      = (SqliteError)Sqlite3.sqlite3_prepare(parent_conn.Handle2, pzStart, pzStart.Length, ref pStmt, ref pzTail);

            if (err != SqliteError.OK)
            {
                throw new SqliteSyntaxException(GetError3());
            }
        }
        private void ThrowError(string statement, string sqlQuery, SqliteError err)
        {
            string errorMsg = Marshal.PtrToStringUni(sqlite3_errmsg16(dbHandle));

            Log.Error("SQLiteClient: {0} cmd:{1} err:{2} detailed:{3} query:{4}",
                      databaseName, statement, err.ToString(), errorMsg, sqlQuery);

            throw new SQLiteException(
                      String.Format("SQLiteClient: {0} cmd:{1} err:{2} detailed:{3} query:{4}", databaseName, statement,
                                    err.ToString(),
                                    errorMsg, sqlQuery), err);
        }
        // Methods

        private void init(string dbName)
        {
            bool isRemotePath = PathIsNetworkPath(dbName);

            if (isRemotePath)
            {
                Log.Info("SQLLiteClient: database is remote {0}", this.DBName);
                WaitForFile(dbName);
            }

            this.DBName  = dbName;
            databaseName = Path.GetFileName(dbName);
            //Log.Info("dbs:open:{0}",databaseName);
            dbHandle = IntPtr.Zero;

            SqliteError err = (SqliteError)sqlite3_open16(dbName, out dbHandle);

            //Log.Info("dbs:opened:{0} {1} {2:X}",databaseName, err.ToString(),dbHandle.ToInt32());
            if (err != SqliteError.OK)
            {
                throw new SQLiteException(string.Format("Failed to open database, SQLite said: {0} {1}", dbName, err.ToString()));
            }
            //Log.Info("dbs:opened:{0} {1:X}",databaseName, dbHandle.ToInt32());
        }
        internal void ReadpVm(string query, SQLiteResultSet set1, ref IntPtr pVm)
        {
            int         pN;
            SqliteError res = SqliteError.ERROR;

            if (pVm == IntPtr.Zero)
            {
                ThrowError("SQLiteClient: pvm=null", query, res);
            }
            DateTime now = DateTime.Now;
            TimeSpan ts  = now - DateTime.Now;

            while (true && ts.TotalSeconds > -15)
            {
                for (int i = 0; i <= busyRetries; i++)
                {
                    res = sqlite3_step(pVm);
                    if (res == SqliteError.LOCKED || res == SqliteError.BUSY)
                    {
                        Thread.Sleep(busyRetryDelay);
                    }
                    else
                    {
                        if (i > 0)
                        {
                            Log.Debug("SqlClient: database was busy (Available after " + (i + 1) + " retries)");
                        }
                        break;
                    }
                }

                pN = sqlite3_column_count(pVm);

                /*
                 * if (res == SqliteError.ERROR)
                 * {
                 * ThrowError("sqlite3_step", query, res);
                 * }
                 */
                if (res == SqliteError.DONE)
                {
                    break;
                }


                // when resuming from hibernation or standby and where the db3 files are located on a network drive, we often end up in a neverending loop
                // while (true)...it never exits. and the app is hanging.
                // Lets handle it by disconnecting the DB, and then reconnect.
                if (res == SqliteError.BUSY || res == SqliteError.ERROR)
                {
                    this.Close();

                    dbHandle = IntPtr.Zero;

                    // bool res2 = WaitForFile(this.DBName);

                    SqliteError err = (SqliteError)sqlite3_open16(this.DBName, out dbHandle);

                    if (err != SqliteError.OK)
                    {
                        throw new SQLiteException(string.Format("Failed to re-open database, SQLite said: {0} {1}", DBName,
                                                                err.ToString()));
                    }
                    else
                    {
                        IntPtr pzTail;
                        err = sqlite3_prepare16(dbHandle, query, query.Length * 2, out pVm, out pzTail);

                        res = sqlite3_step(pVm);
                        pN  = sqlite3_column_count(pVm);

                        if (pVm == IntPtr.Zero)
                        {
                            ThrowError("sqlite3_prepare16:pvm=null", query, err);
                        }
                    }
                }

                // We have some data; lets read it
                if (set1.ColumnNames.Count == 0)
                {
                    for (int i = 0; i < pN; i++)
                    {
                        string colName;
                        IntPtr pName = sqlite3_column_name16(pVm, i);
                        if (pName == IntPtr.Zero)
                        {
                            ThrowError(String.Format("SqlClient:sqlite3_column_name16() returned null {0}/{1}", i, pN), query, res);
                        }
                        colName = Marshal.PtrToStringUni(pName);
                        set1.columnNames.Add(colName);
                        set1.ColumnIndices[colName] = i;
                    }
                }

                SQLiteResultSet.Row row = new SQLiteResultSet.Row();
                for (int i = 0; i < pN; i++)
                {
                    string colData = "";
                    IntPtr pName   = sqlite3_column_text16(pVm, i);
                    if (pName != IntPtr.Zero)
                    {
                        colData = Marshal.PtrToStringUni(pName);
                    }
                    row.fields.Add(colData);
                }
                set1.Rows.Add(row);

                ts = now - DateTime.Now;
            }

            if (res == SqliteError.BUSY || res == SqliteError.ERROR)
            {
                ThrowError("sqlite3_step", query, res);
            }
        }
    private void ThrowError(string statement, string sqlQuery, SqliteError err)
    {
      string errorMsg = Marshal.PtrToStringUni(sqlite3_errmsg16(dbHandle));
      Log.Error("SQLiteClient: {0} cmd:{1} err:{2} detailed:{3} query:{4}",
                databaseName, statement, err.ToString(), errorMsg, sqlQuery);

      throw new SQLiteException(
        String.Format("SQLiteClient: {0} cmd:{1} err:{2} detailed:{3} query:{4}", databaseName, statement,
                      err.ToString(),
                      errorMsg, sqlQuery), err);
    }