Add SL3Statement

FossilOrigin-Name: cc03d24ff3ef295e0a9769b20587ac48cf5172996c09b5420e59eb4407765d63

src/Makefile

@@ -8,7 +8,8 @@ FRAMEWORK = ${OBJSQLITE3_FRAMEWORK}
 LIB_MAJOR = 0
 LIB_MINOR = 0
 
-SRCS = SL3Connection.m
+SRCS = SL3Connection.m	\
+       SL3Statement.m
 INCLUDES := ${SRCS:.m=.h}	\
 	    ObjSQLite3.h
 
@@ -17,7 +18,7 @@ LIB_OBJS_EXTRA = ${EXCEPTIONS_EXCEPTIONS_LIB_A}
 
 include ../buildsys.mk
 
-CPPFLAGS += -I. -Iexceptions
+CPPFLAGS += -I. -Iexceptions -DSL3_PUBLIC_IVARS
 LD = ${OBJC}
 FRAMEWORK_LIBS := ${OBJFW_FRAMEWORK_LIBS} ${LIBS}
 LIBS := ${OBJFW_LIBS} ${LIBS}

src/SL3Connection.h

@@ -28,7 +28,10 @@ OF_ASSUME_NONNULL_BEGIN
 
 @interface SL3Connection: OFObject
 {
-	sqlite3 *_database;
+#ifdef SL3_PUBLIC_IVARS
+@public
+#endif
+	sqlite3 *_db;
 }
 
 + (instancetype)connectionWithPath: (OFString *)path

src/SL3Connection.m

@@ -38,14 +38,12 @@
 	self = [super init];
 
 	@try {
-		int errorCode = sqlite3_open_v2(path.UTF8String, &_database,
+		int code = sqlite3_open_v2(path.UTF8String, &_db, flags, NULL);
-		    flags, NULL);
 
-		if (errorCode != SQLITE_OK)
+		if (code != SQLITE_OK)
-			@throw [SL3OpenFailedException
+			@throw [SL3OpenFailedException exceptionWithPath: path
-			    exceptionWithPath: path
+								   flags: flags
-					flags: flags
+							       errorCode: code];
-				    errorCode: errorCode];
 	} @catch (id e) {
 		[self release];
 		@throw e;
@@ -56,7 +54,7 @@
 
 - (void)dealloc
 {
-	sqlite3_close(_database);
+	sqlite3_close(_db);
 
 	[super dealloc];
 }

src/SL3Statement+Private.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2020, Jonathan Schleifer <js@nil.im>
+ *
+ * https://fossil.nil.im/objsqlite3
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice is present in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#import "SL3Statement.h"
+
+OF_ASSUME_NONNULL_BEGIN
+
+@interface SL3Statement ()
+- (instancetype)sl3_initWithConnection: (SL3Connection *)connection
+			  SQLStatement: (OFConstantString *)SQLStatement;
+@end
+
+OF_ASSUME_NONNULL_END

src/SL3Statement.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2020, Jonathan Schleifer <js@nil.im>
+ *
+ * https://fossil.nil.im/objsqlite3
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice is present in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#import <ObjFW/ObjFW.h>
+
+#include <sqlite3.h>
+
+OF_ASSUME_NONNULL_BEGIN
+
+@class SL3Connection;
+
+@interface SL3Statement: OFObject
+{
+#ifdef SL3_PUBLIC_IVARS
+@public
+#endif
+	SL3Connection *_connection;
+	sqlite3_stmt *_stmt;
+}
+
+- (void)bindWithArray: (OFArray *)array;
+- (void)bindWithDictionary:
+    (OFDictionary OF_GENERIC(OFString *, id) *)dictionary;
+- (void)clearBindings;
+- (void)step;
+- (void)reset;
+@end
+
+OF_ASSUME_NONNULL_END

src/SL3Statement.m

@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2020, Jonathan Schleifer <js@nil.im>
+ *
+ * https://fossil.nil.im/objsqlite3
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice is present in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#import "SL3Statement.h"
+#import "SL3Statement+Private.h"
+
+#import "SL3BindObjectFailedException.h"
+#import "SL3ClearBindingsFailedException.h"
+#import "SL3ExecuteStatementFailedException.h"
+#import "SL3PrepareStatementFailedException.h"
+#import "SL3ResetStatementFailedException.h"
+
+static void
+releaseObject(void *object)
+{
+	[(id)object release];
+}
+
+@implementation SL3Statement
+- (instancetype)sl3_initWithConnection: (SL3Connection *)connection
+			  SQLStatement: (OFConstantString *)SQLStatement
+{
+	self = [super init];
+
+	@try {
+		int code = sqlite3_prepare_v2(connection->_db,
+		    SQLStatement.UTF8String, SQLStatement.UTF8StringLength,
+		    &_stmt, NULL);
+
+		if (code != SQLITE_OK)
+			@throw [SL3PrepareStatementFailedException
+			    exceptionWithConnection: connection
+				       SQLStatement: SQLStatement
+					  errorCode: code];
+
+		_connection = [connection retain];
+	} @catch (id e) {
+		[self release];
+		@throw e;
+	}
+
+	return self;
+}
+
+- (void)dealloc
+{
+	sqlite3_finalize(_stmt);
+	[_connection release];
+
+	[super dealloc];
+}
+
+static void
+bindObject(SL3Statement *statement, int column, id object)
+{
+	int code;
+
+	if ([object isKindOfClass: [OFNumber class]]) {
+		switch (*[object objCType]) {
+		case 'f':
+		case 'd':
+			code = sqlite3_bind_double(statement->_stmt, column,
+			    [object doubleValue]);
+			break;
+		/* TODO: Check for range when converting to signed. */
+		default:
+			code = sqlite3_bind_int64(statement->_stmt, column,
+			    [object longLongValue]);
+			break;
+		}
+	} else if ([object isKindOfClass: [OFString class]]) {
+		OFString *copy = [object copy];
+
+		code = sqlite3_bind_text64(statement->_stmt, column,
+		    copy.UTF8String, copy.UTF8StringLength, releaseObject,
+		    SQLITE_UTF8);
+	} else if ([object isKindOfClass: [OFData class]]) {
+		OFData *copy = [object copy];
+
+		code = sqlite3_bind_blob64(statement->_stmt, column, copy.items,
+		    copy.count * copy.itemSize, releaseObject);
+	} else if ([object isEqual: [OFNull null]])
+		code = sqlite3_bind_null(statement->_stmt, column);
+	else
+		@throw [OFInvalidArgumentException exception];
+
+	if (code != SQLITE_OK)
+		@throw [SL3BindObjectFailedException
+		    exceptionWithObject: object
+				 column: column
+			      statement: statement
+			      errorCode: code];
+}
+
+- (void)bindWithArray: (OFArray *)array
+{
+	void *pool = objc_autoreleasePoolPush();
+	int column = 0;
+
+	if (array.count > sqlite3_bind_parameter_count(_stmt))
+		@throw [OFOutOfRangeException exception];
+
+	for (id object in array)
+		bindObject(self, ++column, object);
+
+	objc_autoreleasePoolPop(pool);
+}
+
+- (void)bindWithDictionary:
+    (OFDictionary OF_GENERIC(OFString *, id) *)dictionary
+{
+	void *pool = objc_autoreleasePoolPush();
+	OFEnumerator OF_GENERIC(OFString *) *keyEnumerator =
+	    [dictionary keyEnumerator];
+	OFEnumerator *objectEnumerator = [dictionary objectEnumerator];
+	OFString *key;
+	id object;
+
+	while ((key = [keyEnumerator nextObject]) != nil &&
+	    (object = [objectEnumerator nextObject]) != nil) {
+		int column = sqlite3_bind_parameter_index(
+		    _stmt, key.UTF8String);
+
+		if (column == 0)
+			@throw [OFUndefinedKeyException
+			    exceptionWithObject: self
+					    key: key];
+
+		bindObject(self, column, object);
+	}
+
+	objc_autoreleasePoolPop(pool);
+}
+
+- (void)clearBindings
+{
+	int code = sqlite3_clear_bindings(_stmt);
+
+	if (code != SQLITE_OK)
+		@throw [SL3ClearBindingsFailedException
+		    exceptionWithStatement: self
+				 errorCode: code];
+}
+
+- (void)step
+{
+	int code = sqlite3_step(_stmt);
+
+	if (code != SQLITE_DONE && code != SQLITE_ROW)
+		@throw [SL3ExecuteStatementFailedException
+		    exceptionWithStatement: self
+				 errorCode: code];
+}
+
+- (void)reset
+{
+	int code = sqlite3_reset(_stmt);
+
+	if (code != SQLITE_OK)
+		@throw [SL3ResetStatementFailedException
+		    exceptionWithStatement: self
+				 errorCode: code];
+}
+@end

src/exceptions/Makefile

@@ -3,11 +3,17 @@ include ../../extra.mk
 STATIC_PIC_LIB_NOINST = ${EXCEPTIONS_LIB_A}
 STATIC_LIB_NOINST = ${EXCEPTIONS_A}
 
-SRCS = SL3Exception.m		\
+SRCS = SL3BindObjectFailedException.m		\
-       SL3OpenFailedException.m
+       SL3ClearBindingsFailedException.m	\
+       SL3Exception.m				\
+       SL3ExecuteStatementFailedException.m	\
+       SL3OpenFailedException.m			\
+       SL3PrepareStatementFailedException.m	\
+       SL3ResetStatementFailedException.m
 
 INCLUDES = ${SRCS:.m=.h}
 
 include ../../buildsys.mk
 
-CPPFLAGS += -I. -I..
+CPPFLAGS += -I. -I.. -DSL3_PUBLIC_IVARS
+

src/exceptions/SL3BindObjectFailedException.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2020, Jonathan Schleifer <js@nil.im>
+ *
+ * https://fossil.nil.im/objsqlite3
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice is present in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#import "SL3Exception.h"
+
+#import "SL3Statement.h"
+
+OF_ASSUME_NONNULL_BEGIN
+
+@interface SL3BindObjectFailedException: SL3Exception
+{
+	id _object;
+	int _column;
+	SL3Statement *_statement;
+}
+
+@property (readonly, nonatomic) id object;
+@property (readonly, nonatomic) int column;
+@property (readonly, nonatomic) SL3Statement *statement;
+
++ (instancetype)exceptionWithConnection: (nullable SL3Connection *)connection
+			      errorCode: (int)errorCode OF_UNAVAILABLE;
++ (instancetype)exceptionWithObject: (id)object
+			     column: (int)column
+			  statement: (SL3Statement *)statement
+			  errorCode: (int)errorCode;
+- (instancetype)initWithConnection: (nullable SL3Connection *)connection
+			 errorCode: (int)errorCode OF_UNAVAILABLE;
+- (instancetype)initWithObject: (id)object
+			column: (int)column
+		     statement: (SL3Statement *)statement
+		     errorCode: (int)errorCode OF_DESIGNATED_INITIALIZER;
+@end
+
+OF_ASSUME_NONNULL_END

src/exceptions/SL3BindObjectFailedException.m

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2020, Jonathan Schleifer <js@nil.im>
+ *
+ * https://fossil.nil.im/objsqlite3
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice is present in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#import "SL3BindObjectFailedException.h"
+
+@implementation SL3BindObjectFailedException
+@synthesize object = _object, column = _column, statement = _statement;
+
++ (instancetype)exceptionWithConnection: (SL3Connection *)connection
+			      errorCode: (int)errorCode
+{
+	OF_UNRECOGNIZED_SELECTOR
+}
+
++ (instancetype)exceptionWithObject: (id)object
+			     column: (int)column
+			  statement: (SL3Statement *)statement
+			  errorCode: (int)errorCode
+{
+	return [[[self alloc] initWithObject: object
+				      column: column
+				   statement: statement
+				   errorCode: errorCode] autorelease];
+}
+
+- (instancetype)initWithConnection: (SL3Connection *)connection
+			 errorCode: (int)errorCode
+{
+	OF_INVALID_INIT_METHOD
+}
+
+- (instancetype)initWithObject: (id)object
+			column: (int)column
+		     statement: (SL3Statement *)statement
+		     errorCode: (int)errorCode
+{
+	self = [super initWithConnection: statement->_connection
+			       errorCode: errorCode];
+
+	@try {
+		_object = [object retain];
+		_statement = [statement retain];
+	} @catch (id e) {
+		[self release];
+		@throw e;
+	}
+
+	return self;
+}
+
+- (void)dealloc
+{
+	[_object release];
+	[_statement release];
+
+	[super dealloc];
+}
+@end

src/exceptions/SL3ClearBindingsFailedException.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020, Jonathan Schleifer <js@nil.im>
+ *
+ * https://fossil.nil.im/objsqlite3
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice is present in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#import "SL3Exception.h"
+
+#import "SL3Statement.h"
+
+OF_ASSUME_NONNULL_BEGIN
+
+@interface SL3ClearBindingsFailedException: SL3Exception
+{
+	SL3Statement *_statement;
+}
+
+@property (readonly, nonatomic) SL3Statement *statement;
+
++ (instancetype)exceptionWithConnection: (nullable SL3Connection *)connection
+			      errorCode: (int)errorCode OF_UNAVAILABLE;
++ (instancetype)exceptionWithStatement: (SL3Statement *)statement
+			     errorCode: (int)errorCode;
+- (instancetype)initWithConnection: (nullable SL3Connection *)connection
+			 errorCode: (int)errorCode OF_UNAVAILABLE;
+- (instancetype)initWithStatement: (SL3Statement *)statement
+			errorCode: (int)errorCode OF_DESIGNATED_INITIALIZER;
+@end
+
+OF_ASSUME_NONNULL_END

src/exceptions/SL3ClearBindingsFailedException.m

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2020, Jonathan Schleifer <js@nil.im>
+ *
+ * https://fossil.nil.im/objsqlite3
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice is present in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#import "SL3ClearBindingsFailedException.h"
+
+@implementation SL3ClearBindingsFailedException
+@synthesize statement = _statement;
+
++ (instancetype)exceptionWithConnection: (SL3Connection *)connection
+			      errorCode: (int)errorCode
+{
+	OF_UNRECOGNIZED_SELECTOR
+}
+
++ (instancetype)exceptionWithStatement: (SL3Statement *)statement
+			     errorCode: (int)errorCode
+{
+	return [[[self alloc] initWithStatement: statement
+				      errorCode: errorCode] autorelease];
+}
+
+- (instancetype)initWithConnection: (SL3Connection *)connection
+			 errorCode: (int)errorCode
+{
+	OF_INVALID_INIT_METHOD
+}
+
+- (instancetype)initWithStatement: (SL3Statement *)statement
+			errorCode: (int)errorCode
+{
+	self = [super initWithConnection: statement->_connection
+			       errorCode: errorCode];
+
+	@try {
+		_statement = [statement retain];
+	} @catch (id e) {
+		[self release];
+		@throw e;
+	}
+
+	return self;
+}
+
+- (void)dealloc
+{
+	[_statement release];
+
+	[super dealloc];
+}
+@end

src/exceptions/SL3OpenFailedException.m

@@ -23,10 +23,10 @@
 #import "SL3OpenFailedException.h"
 
 @implementation SL3OpenFailedException
-@synthesize path = _Path, flags = _flags;
+@synthesize path = _path, flags = _flags;
 
 + (instancetype)exceptionWithConnection: (SL3Connection *)connection
-			      errorCode: (int)errorCode OF_UNAVAILABLE
+			      errorCode: (int)errorCode
 {
 	OF_UNRECOGNIZED_SELECTOR
 }
@@ -41,7 +41,7 @@
 }
 
 - (instancetype)initWithConnection: (SL3Connection *)connection
-			 errorCode: (int)errorCode OF_UNAVAILABLE
+			 errorCode: (int)errorCode
 {
 	OF_INVALID_INIT_METHOD
 }
@@ -63,4 +63,11 @@
 
 	return self;
 }
+
+- (void)dealloc
+{
+	[_path release];
+
+	[super dealloc];
+}
 @end

src/exceptions/SL3PrepareStatementFailedException.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020, Jonathan Schleifer <js@nil.im>
+ *
+ * https://fossil.nil.im/objsqlite3
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice is present in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#import "SL3Exception.h"
+
+OF_ASSUME_NONNULL_BEGIN
+
+@interface SL3PrepareStatementFailedException: SL3Exception
+{
+	OFConstantString *_SQLStatement;
+}
+
+@property (readonly, nonatomic) OFConstantString *SQLStatement;
+
++ (instancetype)exceptionWithConnection: (nullable SL3Connection *)connection
+			      errorCode: (int)errorCode OF_UNAVAILABLE;
++ (instancetype)exceptionWithConnection: (SL3Connection *)connection
+			   SQLStatement: (OFConstantString *)SQLStatement
+			      errorCode: (int)errorCode;
+- (instancetype)initWithConnection: (nullable SL3Connection *)connection
+			 errorCode: (int)errorCode OF_UNAVAILABLE;
+- (instancetype)initWithConnection: (SL3Connection *)connection
+		      SQLStatement: (OFConstantString *)SQLStatement
+			 errorCode: (int)errorCode OF_DESIGNATED_INITIALIZER;
+@end
+
+OF_ASSUME_NONNULL_END

src/exceptions/SL3PrepareStatementFailedException.m

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2020, Jonathan Schleifer <js@nil.im>
+ *
+ * https://fossil.nil.im/objsqlite3
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice is present in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#import "SL3PrepareStatementFailedException.h"
+
+@implementation SL3PrepareStatementFailedException
+@synthesize SQLStatement = _SQLStatement;
+
++ (instancetype)exceptionWithConnection: (SL3Connection *)connection
+			      errorCode: (int)errorCode
+{
+	OF_UNRECOGNIZED_SELECTOR
+}
+
++ (instancetype)exceptionWithConnection: (SL3Connection *)connection
+			   SQLStatement: (OFConstantString *)SQLStatement
+			      errorCode: (int)errorCode;
+{
+	return [[[self alloc] initWithConnection: connection
+				    SQLStatement: SQLStatement
+				       errorCode: errorCode] autorelease];
+}
+
+- (instancetype)initWithConnection: (SL3Connection *)connection
+			 errorCode: (int)errorCode
+{
+	OF_INVALID_INIT_METHOD
+}
+
+- (instancetype)initWithConnection: (SL3Connection *)connection
+		      SQLStatement: (OFConstantString *)SQLStatement
+			 errorCode: (int)errorCode
+{
+	self = [super initWithConnection: connection
+			       errorCode: errorCode];
+
+	@try {
+		_SQLStatement = [SQLStatement retain];
+	} @catch (id e) {
+		[self release];
+		@throw e;
+	}
+
+	return self;
+}
+
+- (void)dealloc
+{
+	[_SQLStatement release];
+
+	[super dealloc];
+}
+@end

src/exceptions/SL3ResetStatementFailedException.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020, Jonathan Schleifer <js@nil.im>
+ *
+ * https://fossil.nil.im/objsqlite3
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice is present in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#import "SL3Exception.h"
+
+#import "SL3Statement.h"
+
+OF_ASSUME_NONNULL_BEGIN
+
+@interface SL3ResetStatementFailedException: SL3Exception
+{
+	SL3Statement *_statement;
+}
+
+@property (readonly, nonatomic) SL3Statement *statement;
+
++ (instancetype)exceptionWithConnection: (nullable SL3Connection *)connection
+			      errorCode: (int)errorCode OF_UNAVAILABLE;
++ (instancetype)exceptionWithStatement: (SL3Statement *)statement
+			     errorCode: (int)errorCode;
+- (instancetype)initWithConnection: (nullable SL3Connection *)connection
+			 errorCode: (int)errorCode OF_UNAVAILABLE;
+- (instancetype)initWithStatement: (SL3Statement *)statement
+			errorCode: (int)errorCode OF_DESIGNATED_INITIALIZER;
+@end
+
+OF_ASSUME_NONNULL_END

src/exceptions/SL3ResetStatementFailedException.m

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2020, Jonathan Schleifer <js@nil.im>
+ *
+ * https://fossil.nil.im/objsqlite3
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice is present in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#import "SL3ResetStatementFailedException.h"
+
+@implementation SL3ResetStatementFailedException
+@synthesize statement = _statement;
+
++ (instancetype)exceptionWithConnection: (SL3Connection *)connection
+			      errorCode: (int)errorCode
+{
+	OF_UNRECOGNIZED_SELECTOR
+}
+
++ (instancetype)exceptionWithStatement: (SL3Statement *)statement
+			     errorCode: (int)errorCode
+{
+	return [[[self alloc] initWithStatement: statement
+				      errorCode: errorCode] autorelease];
+}
+
+- (instancetype)initWithConnection: (SL3Connection *)connection
+			 errorCode: (int)errorCode
+{
+	OF_INVALID_INIT_METHOD
+}
+
+- (instancetype)initWithStatement: (SL3Statement *)statement
+			errorCode: (int)errorCode
+{
+	self = [super initWithConnection: statement->_connection
+			       errorCode: errorCode];
+
+	@try {
+		_statement = [statement retain];
+	} @catch (id e) {
+		[self release];
+		@throw e;
+	}
+
+	return self;
+}
+
+- (void)dealloc
+{
+	[_statement release];
+
+	[super dealloc];
+}
+@end