Merge pull request #23 from gilzoide/repl-sample

Add REPL sample

Author: gilzoide

.gitignore

@@ -1,2 +1,4 @@
 *.o
 *.o~
+Samples
+Samples.meta

Runtime/SQLiteExtensions.cs

@@ -65,5 +65,8 @@ public enum DeserializeFlags : uint
 
         [DllImport(LibraryPath, EntryPoint = "sqlite3_free", CallingConvention = CallingConvention.Cdecl)]
         public static extern void Free(IntPtr ptr);
+
+        [DllImport(LibraryPath, EntryPoint = "sqlite3_column_bytes16", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int ColumnBytes16(IntPtr stmt, int index);
     }
 }

Runtime/SQLitePreparedStatement.cs

@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) 2024 Gil Barbosa Reis
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace SQLite
+{
+    /// <summary>
+    /// Low level SQLite prepared statement object.
+    /// </summary>
+    /// <remarks>
+    /// Using this is the same as using prepared statments in the SQLite C API.
+    /// You need to bind all arguments to the statement, manually step for each row and until done, get values from the
+    /// returned columns, manually reset for subsequent executions, then dispose when not needed anymore.
+    /// </remarks>
+    public class SQLitePreparedStatement : IDisposable
+    {
+        private static readonly IntPtr SQLITE_STATIC = IntPtr.Zero;
+
+        private SQLiteConnection _db;
+        private IntPtr _preparedStatement;
+
+        public SQLitePreparedStatement(SQLiteConnection db, string statement)
+        {
+            if (db == null)
+            {
+                throw new ArgumentNullException(nameof(db));
+            }
+
+            _db = db;
+            _preparedStatement = SQLite3.Prepare2(db.Handle, statement);
+        }
+
+        ~SQLitePreparedStatement()
+        {
+            Dispose();
+        }
+
+        public SQLite3.Result Reset()
+        {
+            ThrowIfDisposed();
+            return SQLite3.Reset(_preparedStatement);
+        }
+
+        public SQLite3.Result Bind(int index, bool value)
+        {
+            ThrowIfDisposed();
+            return (SQLite3.Result) SQLite3.BindInt(_preparedStatement, index, value ? 1 : 0);
+        }
+        public SQLite3.Result Bind(string name, bool value)
+        {
+            ThrowIfDisposed();
+            int index = SQLite3.BindParameterIndex(_preparedStatement, name);
+            return Bind(index, value);
+        }
+
+        public SQLite3.Result Bind(int index, int value)
+        {
+            ThrowIfDisposed();
+            return (SQLite3.Result) SQLite3.BindInt(_preparedStatement, index, value);
+        }
+        public SQLite3.Result Bind(string name, int value)
+        {
+            ThrowIfDisposed();
+            int index = SQLite3.BindParameterIndex(_preparedStatement, name);
+            return Bind(index, value);
+        }
+
+        public SQLite3.Result Bind(int index, long value)
+        {
+            ThrowIfDisposed();
+            return (SQLite3.Result) SQLite3.BindInt64(_preparedStatement, index, value);
+        }
+        public SQLite3.Result Bind(string name, long value)
+        {
+            ThrowIfDisposed();
+            int index = SQLite3.BindParameterIndex(_preparedStatement, name);
+            return Bind(index, value);
+        }
+
+        public SQLite3.Result Bind(int index, float value)
+        {
+            ThrowIfDisposed();
+            return (SQLite3.Result) SQLite3.BindDouble(_preparedStatement, index, value);
+        }
+        public SQLite3.Result Bind(string name, float value)
+        {
+            ThrowIfDisposed();
+            int index = SQLite3.BindParameterIndex(_preparedStatement, name);
+            return Bind(index, value);
+        }
+
+        public SQLite3.Result Bind(int index, double value)
+        {
+            ThrowIfDisposed();
+            return (SQLite3.Result) SQLite3.BindDouble(_preparedStatement, index, value);
+        }
+        public SQLite3.Result Bind(string name, double value)
+        {
+            ThrowIfDisposed();
+            int index = SQLite3.BindParameterIndex(_preparedStatement, name);
+            return Bind(index, value);
+        }
+
+        public SQLite3.Result Bind(int index, string value)
+        {
+            ThrowIfDisposed();
+            return (SQLite3.Result) SQLite3.BindText(_preparedStatement, index, value, value.Length * sizeof(char), SQLITE_STATIC);
+        }
+        public SQLite3.Result Bind(string name, string value)
+        {
+            ThrowIfDisposed();
+            int index = SQLite3.BindParameterIndex(_preparedStatement, name);
+            return Bind(index, value);
+        }
+
+        public SQLite3.Result Bind(int index, byte[] value)
+        {
+            ThrowIfDisposed();
+            return (SQLite3.Result) SQLite3.BindBlob(_preparedStatement, index, value, value.Length, SQLITE_STATIC);
+        }
+        public SQLite3.Result Bind(string name, byte[] value)
+        {
+            ThrowIfDisposed();
+            int index = SQLite3.BindParameterIndex(_preparedStatement, name);
+            return Bind(index, value);
+        }
+
+        public int BindParameterIndex(string name)
+        {
+            ThrowIfDisposed();
+            return SQLite3.BindParameterIndex(_preparedStatement, name);
+        }
+
+        public SQLite3.Result Step()
+        {
+            ThrowIfDisposed();
+            var result = SQLite3.Step(_preparedStatement);
+            if (result > SQLite3.Result.OK && result < SQLite3.Result.Row)
+            {
+                throw SQLiteException.New(result, SQLite3.GetErrmsg(_db.Handle));
+            }
+            return result;
+        }
+
+        public int GetColumnCount()
+        {
+            ThrowIfDisposed();
+            return SQLite3.ColumnCount(_preparedStatement);
+        }
+
+        public string GetColumnName(int column)
+        {
+            ThrowIfDisposed();
+            return SQLite3.ColumnName16(_preparedStatement, column);
+        }
+
+        public IEnumerable<string> EnumerateColumnNames()
+        {
+            for (int i = 0, columnCount = GetColumnCount(); i < columnCount; i++)
+            {
+                yield return GetColumnName(i);
+            }
+        }
+
+        public IEnumerable<string> EnumerateColumnsAsText()
+        {
+            for (int i = 0, columnCount = GetColumnCount(); i < columnCount; i++)
+            {
+                yield return GetString(i);
+            }
+        }
+
+        public bool GetBool(int column)
+        {
+            ThrowIfDisposed();
+            return SQLite3.ColumnInt(_preparedStatement, column) != 0;
+        }
+        
+        public int GetInt(int column)
+        {
+            ThrowIfDisposed();
+            return SQLite3.ColumnInt(_preparedStatement, column);
+        }
+
+        public long GetLong(int column)
+        {
+            ThrowIfDisposed();
+            return SQLite3.ColumnInt64(_preparedStatement, column);
+        }
+
+        public float GetFloat(int column)
+        {
+            ThrowIfDisposed();
+            return (float) SQLite3.ColumnDouble(_preparedStatement, column);
+        }
+
+        public double GetDouble(int column)
+        {
+            ThrowIfDisposed();
+            return SQLite3.ColumnDouble(_preparedStatement, column);
+        }
+
+        public string GetString(int column)
+        {
+            ThrowIfDisposed();
+            IntPtr ptr = SQLite3.ColumnText16(_preparedStatement, column);
+            int sizeInBytes = SQLite3.ColumnBytes16(_preparedStatement, column);
+            return Marshal.PtrToStringUni(ptr, sizeInBytes / sizeof(char));
+        }
+
+        public byte[] GetBytes(int column)
+        {
+            ThrowIfDisposed();
+            IntPtr blob = SQLite3.ColumnBlob(_preparedStatement, column);
+            int sizeInBytes = SQLite3.ColumnBytes(_preparedStatement, column);
+            var value = new byte[sizeInBytes];
+            Marshal.Copy(blob, value, 0, sizeInBytes);
+            return value;
+        }
+
+        public void Dispose()
+        {
+            SQLite3.Finalize(_preparedStatement);
+            _preparedStatement = IntPtr.Zero;
+            _db = null;
+        }
+
+        private void ThrowIfDisposed()
+        {
+            if (_preparedStatement == IntPtr.Zero)
+            {
+                throw new ObjectDisposedException(nameof(_preparedStatement));
+            }
+        }
+    }
+}

Runtime/SQLitePreparedStatement.cs.meta

@@ -0,0 +1,16 @@
+{
+    "name": "Gilzoide.SqliteNet.Samples.REPL",
+    "rootNamespace": "",
+    "references": [
+        "Gilzoide.SqliteNet"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": false,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}