Index: src/Makefile ================================================================== --- src/Makefile +++ src/Makefile @@ -6,18 +6,19 @@ STATIC_LIB = ${OBJSQLITE3_STATIC_LIB} FRAMEWORK = ${OBJSQLITE3_FRAMEWORK} LIB_MAJOR = 0 LIB_MINOR = 0 -SRCS = SL3Connection.m +SRCS = SL3Connection.m \ + SL3Statement.m INCLUDES := ${SRCS:.m=.h} \ ObjSQLite3.h OBJS_EXTRA = ${EXCEPTIONS_EXCEPTIONS_A} 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} Index: src/SL3Connection.h ================================================================== --- src/SL3Connection.h +++ src/SL3Connection.h @@ -26,11 +26,14 @@ OF_ASSUME_NONNULL_BEGIN @interface SL3Connection: OFObject { - sqlite3 *_database; +#ifdef SL3_PUBLIC_IVARS +@public +#endif + sqlite3 *_db; } + (instancetype)connectionWithPath: (OFString *)path flags: (int)flags; - (instancetype)initWithPath: (OFString *)path Index: src/SL3Connection.m ================================================================== --- src/SL3Connection.m +++ src/SL3Connection.m @@ -36,18 +36,16 @@ flags: (int)flags { self = [super init]; @try { - int errorCode = sqlite3_open_v2(path.UTF8String, &_database, - flags, NULL); - - if (errorCode != SQLITE_OK) - @throw [SL3OpenFailedException - exceptionWithPath: path - flags: flags - errorCode: errorCode]; + int code = sqlite3_open_v2(path.UTF8String, &_db, flags, NULL); + + if (code != SQLITE_OK) + @throw [SL3OpenFailedException exceptionWithPath: path + flags: flags + errorCode: code]; } @catch (id e) { [self release]; @throw e; } @@ -54,10 +52,10 @@ return self; } - (void)dealloc { - sqlite3_close(_database); + sqlite3_close(_db); [super dealloc]; } @end ADDED src/SL3Statement+Private.h Index: src/SL3Statement+Private.h ================================================================== --- /dev/null +++ src/SL3Statement+Private.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2020, Jonathan Schleifer + * + * 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 ADDED src/SL3Statement.h Index: src/SL3Statement.h ================================================================== --- /dev/null +++ src/SL3Statement.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2020, Jonathan Schleifer + * + * 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 + +#include + +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 ADDED src/SL3Statement.m Index: src/SL3Statement.m ================================================================== --- /dev/null +++ src/SL3Statement.m @@ -0,0 +1,183 @@ +/* + * Copyright (c) 2020, Jonathan Schleifer + * + * 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 Index: src/exceptions/Makefile ================================================================== --- src/exceptions/Makefile +++ src/exceptions/Makefile @@ -1,13 +1,19 @@ include ../../extra.mk STATIC_PIC_LIB_NOINST = ${EXCEPTIONS_LIB_A} STATIC_LIB_NOINST = ${EXCEPTIONS_A} -SRCS = SL3Exception.m \ - SL3OpenFailedException.m +SRCS = SL3BindObjectFailedException.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 + ADDED src/exceptions/SL3BindObjectFailedException.h Index: src/exceptions/SL3BindObjectFailedException.h ================================================================== --- /dev/null +++ src/exceptions/SL3BindObjectFailedException.h @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2020, Jonathan Schleifer + * + * 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 ADDED src/exceptions/SL3BindObjectFailedException.m Index: src/exceptions/SL3BindObjectFailedException.m ================================================================== --- /dev/null +++ src/exceptions/SL3BindObjectFailedException.m @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2020, Jonathan Schleifer + * + * 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 ADDED src/exceptions/SL3ClearBindingsFailedException.h Index: src/exceptions/SL3ClearBindingsFailedException.h ================================================================== --- /dev/null +++ src/exceptions/SL3ClearBindingsFailedException.h @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2020, Jonathan Schleifer + * + * 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 ADDED src/exceptions/SL3ClearBindingsFailedException.m Index: src/exceptions/SL3ClearBindingsFailedException.m ================================================================== --- /dev/null +++ src/exceptions/SL3ClearBindingsFailedException.m @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2020, Jonathan Schleifer + * + * 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 Index: src/exceptions/SL3OpenFailedException.m ================================================================== --- src/exceptions/SL3OpenFailedException.m +++ src/exceptions/SL3OpenFailedException.m @@ -21,14 +21,14 @@ */ #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 } + (instancetype)exceptionWithPath: (OFString *)path @@ -39,11 +39,11 @@ flags: flags errorCode: errorCode] autorelease]; } - (instancetype)initWithConnection: (SL3Connection *)connection - errorCode: (int)errorCode OF_UNAVAILABLE + errorCode: (int)errorCode { OF_INVALID_INIT_METHOD } - (instancetype)initWithPath: (OFString *)path @@ -61,6 +61,13 @@ @throw e; } return self; } + +- (void)dealloc +{ + [_path release]; + + [super dealloc]; +} @end ADDED src/exceptions/SL3PrepareStatementFailedException.h Index: src/exceptions/SL3PrepareStatementFailedException.h ================================================================== --- /dev/null +++ src/exceptions/SL3PrepareStatementFailedException.h @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2020, Jonathan Schleifer + * + * 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 ADDED src/exceptions/SL3PrepareStatementFailedException.m Index: src/exceptions/SL3PrepareStatementFailedException.m ================================================================== --- /dev/null +++ src/exceptions/SL3PrepareStatementFailedException.m @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2020, Jonathan Schleifer + * + * 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 ADDED src/exceptions/SL3ResetStatementFailedException.h Index: src/exceptions/SL3ResetStatementFailedException.h ================================================================== --- /dev/null +++ src/exceptions/SL3ResetStatementFailedException.h @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2020, Jonathan Schleifer + * + * 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 ADDED src/exceptions/SL3ResetStatementFailedException.m Index: src/exceptions/SL3ResetStatementFailedException.m ================================================================== --- /dev/null +++ src/exceptions/SL3ResetStatementFailedException.m @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2020, Jonathan Schleifer + * + * 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