mirror of
https://github.com/gnustep/libs-sqlclient.git
synced 2025-02-14 07:31:17 +00:00
5617 lines
127 KiB
Objective-C
5617 lines
127 KiB
Objective-C
/* -*-objc-*- */
|
||
|
||
/** Implementation of SQLClient for GNUStep
|
||
Copyright (C) 2004 Free Software Foundation, Inc.
|
||
|
||
Written by: Richard Frith-Macdonald <rfm@gnu.org>
|
||
Date: April 2004
|
||
|
||
This file is part of the SQLClient Library.
|
||
|
||
This library is free software; you can redistribute it and/or
|
||
modify it under the terms of the GNU Lesser General Public
|
||
License as published by the Free Software Foundation; either
|
||
version 3 of the License, or (at your option) any later version.
|
||
|
||
This library is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
Lesser General Public License for more details.
|
||
|
||
You should have received a copy of the GNU Lesser General Public
|
||
License along with this library; if not, write to the Free
|
||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA.
|
||
|
||
$Date$ $Revision$
|
||
*/
|
||
|
||
#import <Foundation/NSArray.h>
|
||
#import <Foundation/NSAutoreleasePool.h>
|
||
#import <Foundation/NSBundle.h>
|
||
#import <Foundation/NSCalendarDate.h>
|
||
#import <Foundation/NSCharacterSet.h>
|
||
#import <Foundation/NSData.h>
|
||
#import <Foundation/NSDate.h>
|
||
#import <Foundation/NSDebug.h>
|
||
#import <Foundation/NSDictionary.h>
|
||
#import <Foundation/NSEnumerator.h>
|
||
#import <Foundation/NSException.h>
|
||
#import <Foundation/NSKeyValueCoding.h>
|
||
#import <Foundation/NSLock.h>
|
||
#import <Foundation/NSHashTable.h>
|
||
#import <Foundation/NSMapTable.h>
|
||
#import <Foundation/NSNotification.h>
|
||
#import <Foundation/NSNull.h>
|
||
#import <Foundation/NSObjCRuntime.h>
|
||
#import <Foundation/NSPathUtilities.h>
|
||
#import <Foundation/NSProcessInfo.h>
|
||
#import <Foundation/NSRunLoop.h>
|
||
#import <Foundation/NSSet.h>
|
||
#import <Foundation/NSString.h>
|
||
#import <Foundation/NSThread.h>
|
||
#import <Foundation/NSTimer.h>
|
||
#import <Foundation/NSUserDefaults.h>
|
||
#import <Foundation/NSValue.h>
|
||
|
||
#import <Performance/GSCache.h>
|
||
#import <Performance/GSTicker.h>
|
||
|
||
#define SQLCLIENT_PRIVATE @public
|
||
#define SQLCLIENT_COMPILE_TIME_QUOTE_CHECK 1
|
||
|
||
#include <memory.h>
|
||
|
||
#include "SQLClient.h"
|
||
|
||
#if defined(GNUSTEP_BASE_LIBRARY)
|
||
#define SUBCLASS_RESPONSIBILITY [self subclassResponsibility: _cmd];
|
||
#else
|
||
#define SUBCLASS_RESPONSIBILITY
|
||
#endif
|
||
|
||
NSString * const SQLClientDidConnectNotification
|
||
= @"SQLClientDidConnectNotification";
|
||
|
||
NSString * const SQLClientDidDisconnectNotification
|
||
= @"SQLClientDidDisconnectNotification";
|
||
|
||
static unsigned int classDebugging = 0;
|
||
static NSTimeInterval classDuration = -1;
|
||
|
||
static NSNull *null = nil;
|
||
static NSArray *queryModes = nil;
|
||
static NSThread *mainThread = nil;
|
||
static Class NSStringClass = Nil;
|
||
static Class NSArrayClass = Nil;
|
||
static Class NSDateClass = Nil;
|
||
static Class NSSetClass = Nil;
|
||
static Class SQLClientClass = Nil;
|
||
static Class LitProxyClass = Nil;
|
||
static Class LitStringClass = Nil;
|
||
static Class TinyStringClass = Nil;
|
||
static Class SQLStringClass = Nil;
|
||
static unsigned SQLStringSize = 0;
|
||
|
||
static BOOL autoquote = NO;
|
||
static BOOL autoquoteWarning = NO;
|
||
|
||
static BOOL
|
||
isByteCoding(NSStringEncoding encoding)
|
||
{
|
||
if (NSASCIIStringEncoding == encoding
|
||
|| NSNEXTSTEPStringEncoding == encoding
|
||
|| NSISOLatin1StringEncoding == encoding
|
||
|| NSISOLatin2StringEncoding == encoding
|
||
|| NSISOThaiStringEncoding == encoding
|
||
|| NSISOLatin9StringEncoding == encoding)
|
||
{
|
||
return YES;
|
||
}
|
||
return NO;
|
||
}
|
||
|
||
/* Determine the length of the UTF-8 string as a unicode (UTF-16) string.
|
||
* sets the ascii flag according to the content found.
|
||
*/
|
||
static NSUInteger
|
||
lengthUTF8(const uint8_t *p, unsigned l, BOOL *ascii, BOOL *latin1)
|
||
{
|
||
const uint8_t *e = p + l;
|
||
BOOL a = YES;
|
||
BOOL l1 = YES;
|
||
|
||
l = 0;
|
||
while (p < e)
|
||
{
|
||
uint8_t c = *p;
|
||
uint32_t u = c;
|
||
|
||
if (c > 0x7f)
|
||
{
|
||
int i, sle = 0;
|
||
|
||
a = NO;
|
||
/* calculated the expected sequence length */
|
||
while (c & 0x80)
|
||
{
|
||
c = c << 1;
|
||
sle++;
|
||
}
|
||
|
||
/* legal ? */
|
||
if ((sle < 2) || (sle > 6))
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Bad sequence length in constant string"];
|
||
}
|
||
|
||
if (p + sle > e)
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Short data in constant string"];
|
||
}
|
||
|
||
/* get the codepoint */
|
||
for (i = 1; i < sle; i++)
|
||
{
|
||
if (p[i] < 0x80 || p[i] >= 0xc0)
|
||
break;
|
||
u = (u << 6) | (p[i] & 0x3f);
|
||
}
|
||
|
||
if (i < sle)
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Codepoint out of range in constant string"];
|
||
}
|
||
u = u & ~(0xffffffff << ((5 * sle) + 1));
|
||
p += sle;
|
||
|
||
/*
|
||
* We check for invalid codepoints here.
|
||
*/
|
||
if (u > 0x10ffff)
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Codepoint invalid in constant string"];
|
||
}
|
||
|
||
if ((u >= 0xd800) && (u <= 0xdfff))
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Bad surrogate pair in constant string"];
|
||
}
|
||
}
|
||
else
|
||
{
|
||
p++;
|
||
}
|
||
|
||
/*
|
||
* Add codepoint as either a single unichar for BMP
|
||
* or as a pair of surrogates for codepoints over 16 bits.
|
||
*/
|
||
if (u < 0x10000)
|
||
{
|
||
l++;
|
||
if (u > 255)
|
||
{
|
||
l1 = NO;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
l += 2;
|
||
l1 = NO;
|
||
}
|
||
}
|
||
if (0 != ascii)
|
||
{
|
||
*ascii = a;
|
||
}
|
||
if (0 != latin1)
|
||
{
|
||
*latin1 = l1;
|
||
}
|
||
return l;
|
||
}
|
||
|
||
/*
|
||
*/
|
||
@interface SQLString: SQLLiteral
|
||
{
|
||
@public
|
||
NSUInteger hash;
|
||
BOOL hasHash;
|
||
BOOL ascii;
|
||
BOOL latin1;
|
||
const uint8_t *utf8Bytes;
|
||
NSUInteger byteLen;
|
||
NSUInteger charLen;
|
||
}
|
||
@end
|
||
|
||
@interface SQLLiteralProxy: SQLLiteral
|
||
{
|
||
@public
|
||
NSString *content;
|
||
}
|
||
@end
|
||
|
||
BOOL
|
||
SQLClientIsLiteral(NSString *aString)
|
||
{
|
||
if (nil != aString)
|
||
{
|
||
Class c = object_getClass(aString);
|
||
|
||
if (c == LitStringClass || c == TinyStringClass
|
||
|| c == SQLStringClass || c == LitProxyClass)
|
||
{
|
||
return YES;
|
||
}
|
||
}
|
||
return NO;
|
||
}
|
||
|
||
SQLLiteral *
|
||
SQLClientNewLiteral(const char *bytes, unsigned count)
|
||
{
|
||
SQLString *s;
|
||
uint8_t *p;
|
||
|
||
s = NSAllocateObject(SQLStringClass, count+1, NSDefaultMallocZone());
|
||
s->utf8Bytes = p = ((uint8_t*)(void*)s) + SQLStringSize;
|
||
s->byteLen = count;
|
||
memcpy(p, bytes, count);
|
||
p[count] = '\0';
|
||
s->charLen = lengthUTF8(s->utf8Bytes, s->byteLen, &s->ascii, &s->latin1);
|
||
return s;
|
||
}
|
||
|
||
SQLLiteral *
|
||
SQLClientCopyLiteral(NSString *aString)
|
||
{
|
||
if (nil != aString)
|
||
{
|
||
Class c = object_getClass(aString);
|
||
|
||
if (c == LitProxyClass)
|
||
{
|
||
aString = ((SQLLiteralProxy*)aString)->content;
|
||
c = object_getClass(aString);
|
||
}
|
||
if (c != LitStringClass && c != TinyStringClass && c != SQLStringClass)
|
||
{
|
||
/* The SQLString class uses utf8 and can be very inefficient
|
||
* if it's too long. For long strings we use a proxy instead.
|
||
*/
|
||
if ([aString length] > 64)
|
||
{
|
||
SQLLiteralProxy *l;
|
||
|
||
l = (SQLLiteralProxy*)
|
||
NSAllocateObject(LitProxyClass, 0, NSDefaultMallocZone());
|
||
l->content = [aString copy];
|
||
aString = l;
|
||
}
|
||
else
|
||
{
|
||
const char *p = [aString UTF8String];
|
||
int l = strlen(p);
|
||
|
||
aString = SQLClientNewLiteral(p, l);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
aString = [aString copy];
|
||
}
|
||
}
|
||
return (SQLLiteral*)aString;
|
||
}
|
||
|
||
SQLLiteral *
|
||
SQLClientMakeLiteral(NSString *aString)
|
||
{
|
||
if (nil != aString)
|
||
{
|
||
Class c = object_getClass(aString);
|
||
|
||
if (c == LitProxyClass)
|
||
{
|
||
aString = ((SQLLiteralProxy*)aString)->content;
|
||
c = object_getClass(aString);
|
||
}
|
||
if (c != LitStringClass && c != TinyStringClass && c != SQLStringClass)
|
||
{
|
||
/* The SQLString class uses utf8 and can be very inefficient
|
||
* if it's too long. For long strings we use a proxy to a
|
||
* copy of the original string.
|
||
*/
|
||
if ([aString length] > 64)
|
||
{
|
||
SQLLiteralProxy *l;
|
||
|
||
l = (SQLLiteralProxy*)
|
||
NSAllocateObject(LitProxyClass, 0, NSDefaultMallocZone());
|
||
l->content = [aString copy];
|
||
return (SQLLiteral*)[l autorelease];
|
||
}
|
||
else
|
||
{
|
||
const char *p = [aString UTF8String];
|
||
int l = strlen(p);
|
||
NSString *s = SQLClientNewLiteral(p, l);
|
||
|
||
aString = [s autorelease];
|
||
}
|
||
}
|
||
}
|
||
return (SQLLiteral*)aString;
|
||
}
|
||
|
||
SQLLiteral *
|
||
SQLClientProxyLiteral(NSString *aString)
|
||
{
|
||
if (nil == aString)
|
||
{
|
||
return nil;
|
||
}
|
||
else if (SQLClientIsLiteral(aString))
|
||
{
|
||
return (SQLLiteral*)[[aString retain] autorelease];
|
||
}
|
||
else if (NO == [aString isKindOfClass: NSStringClass])
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Attempt to cast non-string to SQLLiteral"];
|
||
return nil;
|
||
}
|
||
else
|
||
{
|
||
SQLLiteralProxy *l;
|
||
|
||
l = (SQLLiteralProxy*)
|
||
NSAllocateObject(LitProxyClass, 0, NSDefaultMallocZone());
|
||
l->content = [aString retain];
|
||
return (SQLLiteral*)[l autorelease];
|
||
}
|
||
}
|
||
|
||
NSString *
|
||
SQLClientUnProxyLiteral(id aString)
|
||
{
|
||
if (nil != aString)
|
||
{
|
||
Class c = object_getClass(aString);
|
||
|
||
if (c == LitProxyClass)
|
||
{
|
||
aString = ((SQLLiteralProxy*)aString)->content;
|
||
}
|
||
else if (c != LitStringClass
|
||
&& c != TinyStringClass
|
||
&& c != SQLStringClass)
|
||
{
|
||
aString = [aString description];
|
||
if (YES == autoquoteWarning)
|
||
{
|
||
NSLog(@"SQLClient expected SQLLiteral type for %@ (%@)",
|
||
aString, NSStringFromClass(c));
|
||
}
|
||
}
|
||
}
|
||
return (NSString*)aString;
|
||
}
|
||
|
||
static SQLLiteral *
|
||
quoteBigInteger(int64_t i)
|
||
{
|
||
char buf[32];
|
||
unsigned len;
|
||
SQLLiteral *s;
|
||
|
||
len = sprintf(buf, "%"PRId64, i);
|
||
s = SQLClientNewLiteral(buf, len);
|
||
return [s autorelease];
|
||
}
|
||
|
||
@interface SQLClientPool (Swallow)
|
||
- (BOOL) _swallowClient: (SQLClient*)client explicit: (BOOL)swallowed;
|
||
@end
|
||
@interface SQLTransaction (Creation)
|
||
+ (SQLTransaction*) _transactionUsing: (id)clientOrPool
|
||
batch: (BOOL)isBatched
|
||
stop: (BOOL)stopOnFailure;
|
||
@end
|
||
|
||
@implementation SQLLiteral
|
||
+ (id) allocWithZone: (NSZone*)z
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Illegal attempt to allocate instance of SQLLiteral"];
|
||
return nil;
|
||
}
|
||
- (id) copy
|
||
{
|
||
return RETAIN(self);
|
||
}
|
||
- (id) copyWithZone: (NSZone*)z
|
||
{
|
||
return RETAIN(self);
|
||
}
|
||
@end
|
||
|
||
@implementation SQLLiteralProxy
|
||
- (unichar) characterAtIndex: (NSUInteger)i
|
||
{
|
||
return [content characterAtIndex: i];
|
||
}
|
||
- (void) dealloc
|
||
{
|
||
[content release];
|
||
[super dealloc];
|
||
}
|
||
- (void) getCharacters: (unichar*)buffer
|
||
{
|
||
[content getCharacters: buffer];
|
||
}
|
||
- (void) getCharacters: (unichar*)buffer
|
||
range: (NSRange)aRange
|
||
{
|
||
return [content getCharacters: buffer range: aRange];
|
||
}
|
||
- (NSUInteger) hash
|
||
{
|
||
return [content hash];
|
||
}
|
||
- (BOOL) isEqual: (id)other
|
||
{
|
||
return [content isEqual: other];
|
||
}
|
||
- (NSUInteger) length
|
||
{
|
||
return [content length];
|
||
}
|
||
- (const char *) UTF8String
|
||
{
|
||
return [content UTF8String];
|
||
}
|
||
@end
|
||
|
||
@implementation SQLRecordKeys
|
||
|
||
- (NSUInteger) count
|
||
{
|
||
return count;
|
||
}
|
||
|
||
- (void) dealloc
|
||
{
|
||
if (nil != order) [order release];
|
||
if (nil != map) [map release];
|
||
if (nil != low) [low release];
|
||
[super dealloc];
|
||
}
|
||
|
||
- (NSUInteger) indexForKey: (NSString*)key
|
||
{
|
||
NSUInteger c;
|
||
|
||
c = (NSUInteger)NSMapGet(map, key);
|
||
if (c > 0)
|
||
{
|
||
return c - 1;
|
||
}
|
||
key = [key lowercaseString];
|
||
c = (NSUInteger)NSMapGet(low, key);
|
||
if (c > 0)
|
||
{
|
||
if (classDebugging > 0)
|
||
{
|
||
NSLog(@"[SQLRecordKeys-indexForKey:] lowercase '%@'", key);
|
||
}
|
||
return c - 1;
|
||
}
|
||
return NSNotFound;
|
||
}
|
||
|
||
- (id) initWithKeys: (NSString**)keys count: (NSUInteger)c
|
||
{
|
||
if (nil != (self = [super init]))
|
||
{
|
||
count = c;
|
||
order = [[NSArray alloc] initWithObjects: keys count: c];
|
||
map = NSCreateMapTable(NSObjectMapKeyCallBacks,
|
||
NSIntegerMapValueCallBacks, count);
|
||
low = NSCreateMapTable(NSObjectMapKeyCallBacks,
|
||
NSIntegerMapValueCallBacks, count);
|
||
for (c = 1; c <= count; c++)
|
||
{
|
||
NSString *k = keys[c-1];
|
||
|
||
NSMapInsert(map, (void*)k, (void*)c);
|
||
k = [k lowercaseString];
|
||
NSMapInsert(low, (void*)k, (void*)c);
|
||
}
|
||
}
|
||
return self;
|
||
}
|
||
|
||
- (NSArray*) order
|
||
{
|
||
return order;
|
||
}
|
||
|
||
- (NSUInteger) sizeInBytesExcluding: (NSHashTable*)exclude
|
||
{
|
||
NSUInteger size = [super sizeInBytesExcluding: exclude];
|
||
|
||
if (size > 0)
|
||
{
|
||
if (0 == bytes)
|
||
{
|
||
bytes = size;
|
||
bytes += [order sizeInBytesExcluding: exclude];
|
||
bytes += [map sizeInBytesExcluding: exclude];
|
||
bytes += [low sizeInBytesExcluding: exclude];
|
||
}
|
||
size = bytes;
|
||
}
|
||
return size;
|
||
}
|
||
|
||
@end
|
||
|
||
|
||
@interface _ConcreteSQLRecord : SQLRecord
|
||
{
|
||
SQLRecordKeys *keys;
|
||
NSUInteger count; // Must be last
|
||
}
|
||
@end
|
||
|
||
@interface CacheQuery : NSObject
|
||
{
|
||
@public
|
||
SQLLiteral *query;
|
||
id recordType;
|
||
id listType;
|
||
unsigned lifetime;
|
||
}
|
||
@end
|
||
|
||
@implementation CacheQuery
|
||
- (void) dealloc
|
||
{
|
||
[query release];
|
||
[super dealloc];
|
||
}
|
||
@end
|
||
|
||
static Class aClass = 0;
|
||
static Class rClass = 0;
|
||
|
||
@implementation SQLRecord
|
||
+ (id) allocWithZone: (NSZone*)aZone
|
||
{
|
||
NSLog(@"Illegal attempt to allocate an SQLRecord");
|
||
return nil;
|
||
}
|
||
|
||
+ (void) initialize
|
||
{
|
||
GSTickerTimeNow();
|
||
if (nil == null)
|
||
{
|
||
null = [NSNull new];
|
||
}
|
||
if (Nil == aClass)
|
||
{
|
||
aClass = [NSMutableArray class];
|
||
}
|
||
if (Nil == rClass)
|
||
{
|
||
rClass = [_ConcreteSQLRecord class];
|
||
}
|
||
}
|
||
|
||
+ (id) newWithValues: (id*)v keys: (NSString**)k count: (unsigned int)c
|
||
{
|
||
return [rClass newWithValues: v keys: k count: c];
|
||
}
|
||
|
||
+ (id) newWithValues: (id*)v keys: (SQLRecordKeys*)k
|
||
{
|
||
return [rClass newWithValues: v keys: k];
|
||
}
|
||
|
||
- (NSArray*) allKeys
|
||
{
|
||
NSUInteger count = [self count];
|
||
|
||
if (count > 0)
|
||
{
|
||
id buf[count];
|
||
|
||
while (count-- > 0)
|
||
{
|
||
buf[count] = [self keyAtIndex: count];
|
||
}
|
||
return [NSArray arrayWithObjects: buf count: count];
|
||
}
|
||
else
|
||
{
|
||
return [NSArray array];
|
||
}
|
||
}
|
||
|
||
- (id) copyWithZone: (NSZone*)z
|
||
{
|
||
return [self retain];
|
||
}
|
||
|
||
- (NSUInteger) count
|
||
{
|
||
SUBCLASS_RESPONSIBILITY
|
||
return 0;
|
||
}
|
||
|
||
- (NSMutableDictionary*) dictionary
|
||
{
|
||
NSUInteger count = [self count];
|
||
|
||
if (count > 0)
|
||
{
|
||
id keys[count];
|
||
id vals[count];
|
||
|
||
[self getKeys: keys];
|
||
[self getObjects: vals];
|
||
return [NSMutableDictionary dictionaryWithObjects: vals
|
||
forKeys: keys
|
||
count: count];
|
||
}
|
||
else
|
||
{
|
||
return [NSMutableDictionary dictionary];
|
||
}
|
||
}
|
||
|
||
- (void) getKeys: (id*)buf
|
||
{
|
||
NSUInteger i = [self count];
|
||
|
||
while (i-- > 0)
|
||
{
|
||
buf[i] = [self keyAtIndex: i];
|
||
}
|
||
}
|
||
|
||
- (void) getObjects: (id*)buf
|
||
{
|
||
NSUInteger i = [self count];
|
||
|
||
while (i-- > 0)
|
||
{
|
||
buf[i] = [self objectAtIndex: i];
|
||
}
|
||
}
|
||
|
||
- (id) init
|
||
{
|
||
NSLog(@"Illegal attempt to -init an SQLRecord");
|
||
[self release];
|
||
return nil;
|
||
}
|
||
|
||
- (NSString*) keyAtIndex: (NSUInteger)index
|
||
{
|
||
SUBCLASS_RESPONSIBILITY
|
||
return nil;
|
||
}
|
||
|
||
- (SQLRecordKeys*) keys
|
||
{
|
||
return nil;
|
||
}
|
||
|
||
- (id) objectAtIndex: (NSUInteger)index
|
||
{
|
||
SUBCLASS_RESPONSIBILITY
|
||
return nil;
|
||
}
|
||
|
||
- (id) objectForKey: (NSString*)key
|
||
{
|
||
NSUInteger count = [self count];
|
||
|
||
if (count > 0)
|
||
{
|
||
NSUInteger pos;
|
||
id keys[count];
|
||
|
||
[self getKeys: keys];
|
||
for (pos = 0; pos < count; pos++)
|
||
{
|
||
if ([key isEqualToString: keys[pos]] == YES)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
if (pos == count)
|
||
{
|
||
for (pos = 0; pos < count; pos++)
|
||
{
|
||
if ([key caseInsensitiveCompare: keys[pos]] == NSOrderedSame)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (pos != count)
|
||
{
|
||
return [self objectAtIndex: pos];
|
||
}
|
||
}
|
||
return nil;
|
||
}
|
||
|
||
- (void) replaceObjectAtIndex: (NSUInteger)index withObject: (id)anObject
|
||
{
|
||
SUBCLASS_RESPONSIBILITY
|
||
}
|
||
|
||
- (void) setObject: (id)anObject forKey: (NSString*)aKey
|
||
{
|
||
NSUInteger count = [self count];
|
||
|
||
if (count > 0)
|
||
{
|
||
NSUInteger pos;
|
||
id keys[count];
|
||
|
||
if (anObject == nil)
|
||
{
|
||
anObject = null;
|
||
}
|
||
[self getKeys: keys];
|
||
for (pos = 0; pos < count; pos++)
|
||
{
|
||
if ([aKey isEqualToString: keys[pos]] == YES)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
if (pos == count)
|
||
{
|
||
for (pos = 0; pos < count; pos++)
|
||
{
|
||
if ([aKey caseInsensitiveCompare: keys[pos]] == NSOrderedSame)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (pos == count)
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Bad key (%@) in -setObject:forKey:", aKey];
|
||
}
|
||
else
|
||
{
|
||
[self replaceObjectAtIndex: pos withObject: anObject];
|
||
}
|
||
}
|
||
else
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Bad key (%@) in -setObject:forKey:", aKey];
|
||
}
|
||
}
|
||
|
||
- (NSUInteger) sizeInBytes: (NSMutableSet*)exclude
|
||
{
|
||
NSUInteger size = [super sizeInBytes: exclude];
|
||
NSUInteger count = [self count];
|
||
|
||
if (size > 0 && count > 0)
|
||
{
|
||
NSUInteger pos;
|
||
id vals[count];
|
||
|
||
[self getObjects: vals];
|
||
for (pos = 0; pos < count; pos++)
|
||
{
|
||
size += [vals[pos] sizeInBytes: exclude];
|
||
}
|
||
}
|
||
return size;
|
||
}
|
||
|
||
@end
|
||
|
||
@implementation SQLRecord (KVC)
|
||
- (void) setValue: (id)aValue forKey: (NSString*)aKey
|
||
{
|
||
[self setObject: aValue forKey: aKey];
|
||
}
|
||
- (id) valueForKey: (NSString*)aKey
|
||
{
|
||
id v = [self objectForKey: aKey];
|
||
|
||
if (v == nil)
|
||
{
|
||
v = [super valueForKey: aKey];
|
||
}
|
||
return v;
|
||
}
|
||
@end
|
||
|
||
|
||
@implementation _ConcreteSQLRecord
|
||
|
||
+ (id) newWithValues: (id*)v keys: (SQLRecordKeys*)k
|
||
{
|
||
id *ptr;
|
||
_ConcreteSQLRecord *r;
|
||
NSUInteger c;
|
||
|
||
c = [k count];
|
||
r = (_ConcreteSQLRecord*)NSAllocateObject(self,
|
||
c*sizeof(id), NSDefaultMallocZone());
|
||
r->count = c;
|
||
r->keys = [k retain];
|
||
ptr = (id*)(((void*)&(r->count)) + sizeof(r->count));
|
||
while (c-- > 0)
|
||
{
|
||
if (nil == v[c])
|
||
{
|
||
ptr[c] = [null retain];
|
||
}
|
||
else
|
||
{
|
||
ptr[c] = [v[c] retain];
|
||
}
|
||
}
|
||
return r;
|
||
}
|
||
|
||
+ (id) newWithValues: (id*)v keys: (NSString**)k count: (unsigned int)c
|
||
{
|
||
SQLRecordKeys *o;
|
||
_ConcreteSQLRecord *r;
|
||
|
||
o = [[SQLRecordKeys alloc] initWithKeys: k count: c];
|
||
r = [self newWithValues: v keys: o];
|
||
[o release];
|
||
return r;
|
||
}
|
||
|
||
- (NSArray*) allKeys
|
||
{
|
||
return [keys order];
|
||
}
|
||
|
||
- (id) copyWithZone: (NSZone*)z
|
||
{
|
||
return [self retain];
|
||
}
|
||
|
||
- (NSUInteger) count
|
||
{
|
||
return count;
|
||
}
|
||
|
||
- (void) dealloc
|
||
{
|
||
id *ptr;
|
||
NSUInteger pos;
|
||
|
||
[keys release];
|
||
ptr = (id*)(((void*)&count) + sizeof(count));
|
||
for (pos = 0; pos < count; pos++)
|
||
{
|
||
[ptr[pos] release]; ptr[pos] = nil;
|
||
}
|
||
[super dealloc];
|
||
}
|
||
|
||
- (NSMutableDictionary*) dictionary
|
||
{
|
||
NSMutableDictionary *d;
|
||
NSUInteger pos;
|
||
NSArray *k = [keys order];
|
||
id *ptr;
|
||
|
||
ptr = (id*)(((void*)&count) + sizeof(count));
|
||
d = [NSMutableDictionary dictionaryWithCapacity: count];
|
||
for (pos = 0; pos < count; pos++)
|
||
{
|
||
[d setObject: ptr[pos]
|
||
forKey: [[k objectAtIndex: pos] lowercaseString]];
|
||
}
|
||
return d;
|
||
}
|
||
|
||
- (void) getKeys: (id*)buf
|
||
{
|
||
[[keys order] getObjects: buf];
|
||
}
|
||
|
||
- (void) getObjects: (id*)buf
|
||
{
|
||
id *ptr;
|
||
NSUInteger pos;
|
||
|
||
ptr = (id*)(((void*)&count) + sizeof(count));
|
||
for (pos = 0; pos < count; pos++)
|
||
{
|
||
buf[pos] = ptr[pos];
|
||
}
|
||
}
|
||
|
||
- (id) init
|
||
{
|
||
NSLog(@"Illegal attempt to -init an SQLRecord");
|
||
[self release];
|
||
return nil;
|
||
}
|
||
|
||
- (NSString*) keyAtIndex: (NSUInteger)pos
|
||
{
|
||
return [[keys order] objectAtIndex: pos];
|
||
}
|
||
|
||
- (SQLRecordKeys*) keys
|
||
{
|
||
return keys;
|
||
}
|
||
|
||
- (id) objectAtIndex: (NSUInteger)pos
|
||
{
|
||
id *ptr;
|
||
|
||
if (pos >= count)
|
||
{
|
||
[NSException raise: NSRangeException
|
||
format: @"Array index too large"];
|
||
}
|
||
ptr = (id*)(((void*)&count) + sizeof(count));
|
||
return ptr[pos];
|
||
}
|
||
|
||
- (id) objectForKey: (NSString*)key
|
||
{
|
||
NSUInteger pos = [keys indexForKey: key];
|
||
|
||
if (NSNotFound == pos)
|
||
{
|
||
return nil;
|
||
}
|
||
else
|
||
{
|
||
id *ptr;
|
||
|
||
ptr = (id*)(((void*)&count) + sizeof(count));
|
||
return ptr[pos];
|
||
}
|
||
}
|
||
|
||
- (void) replaceObjectAtIndex: (NSUInteger)index withObject: (id)anObject
|
||
{
|
||
id *ptr;
|
||
|
||
if (index >= count)
|
||
{
|
||
[NSException raise: NSRangeException
|
||
format: @"Array index too large"];
|
||
}
|
||
if (anObject == nil)
|
||
{
|
||
anObject = null;
|
||
}
|
||
ptr = (id*)(((void*)&count) + sizeof(count));
|
||
ptr += index;
|
||
[anObject retain];
|
||
[*ptr release];
|
||
*ptr = anObject;
|
||
}
|
||
|
||
- (void) setObject: (id)anObject forKey: (NSString*)aKey
|
||
{
|
||
id *ptr;
|
||
NSUInteger pos;
|
||
|
||
if (anObject == nil)
|
||
{
|
||
anObject = null;
|
||
}
|
||
ptr = (id*)(((void*)&count) + sizeof(count));
|
||
pos = [keys indexForKey: aKey];
|
||
if (NSNotFound == pos)
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Bad key (%@) in -setObject:forKey:", aKey];
|
||
}
|
||
else
|
||
{
|
||
[anObject retain];
|
||
[ptr[pos] release];
|
||
ptr[pos] = anObject;
|
||
}
|
||
}
|
||
|
||
- (NSUInteger) sizeInBytes: (NSMutableSet*)exclude
|
||
{
|
||
if ([exclude member: self] != nil)
|
||
{
|
||
return 0;
|
||
}
|
||
else
|
||
{
|
||
NSUInteger size = [super sizeInBytes: exclude];
|
||
NSUInteger pos;
|
||
id *ptr;
|
||
|
||
ptr = (id*)(((void*)&count) + sizeof(count));
|
||
for (pos = 0; pos < count; pos++)
|
||
{
|
||
size += [ptr[pos] sizeInBytes: exclude];
|
||
}
|
||
return size;
|
||
}
|
||
}
|
||
|
||
- (NSUInteger) sizeInBytesExcluding: (NSHashTable*)exclude
|
||
{
|
||
static NSUInteger (*imp)(id,SEL,id) = 0;
|
||
NSUInteger size;
|
||
|
||
/* We use the NSObject implementation to get the memory used,
|
||
* and then add in the fields within the record.
|
||
*/
|
||
if (0 == imp)
|
||
{
|
||
imp = (NSUInteger(*)(id,SEL,id))
|
||
[NSObject instanceMethodForSelector: _cmd];
|
||
}
|
||
size = (*imp)(self, _cmd, exclude);
|
||
if (size > 0)
|
||
{
|
||
NSUInteger pos;
|
||
id *ptr;
|
||
|
||
size += [keys sizeInBytesExcluding: exclude];
|
||
size += sizeof(void*) * count;
|
||
ptr = (id*)(((void*)&count) + sizeof(count));
|
||
for (pos = 0; pos < count; pos++)
|
||
{
|
||
size += [ptr[pos] sizeInBytesExcluding: exclude];
|
||
}
|
||
}
|
||
return size;
|
||
}
|
||
|
||
@end
|
||
|
||
/**
|
||
* Exception raised when an error with the remote database server occurs.
|
||
*/
|
||
NSString *SQLException = @"SQLException";
|
||
/**
|
||
* Exception for when a connection to the server is lost.
|
||
*/
|
||
NSString *SQLConnectionException = @"SQLConnectionException";
|
||
/**
|
||
* Exception for when a query is supposed to return data and doesn't.
|
||
*/
|
||
NSString *SQLEmptyException = @"SQLEmptyException";
|
||
/**
|
||
* Exception for when an insert/update would break the uniqueness of a
|
||
* field or index.
|
||
*/
|
||
NSString *SQLUniqueException = @"SQLUniqueException";
|
||
|
||
@implementation SQLClient (Logging)
|
||
|
||
+ (unsigned int) debugging
|
||
{
|
||
return classDebugging;
|
||
}
|
||
|
||
+ (NSTimeInterval) durationLogging
|
||
{
|
||
return classDuration;
|
||
}
|
||
|
||
+ (void) setDebugging: (unsigned int)level
|
||
{
|
||
classDebugging = level;
|
||
}
|
||
|
||
+ (void) setDurationLogging: (NSTimeInterval)threshold
|
||
{
|
||
classDuration = threshold;
|
||
}
|
||
|
||
- (void) debug: (NSString*)fmt, ...
|
||
{
|
||
va_list ap;
|
||
|
||
va_start(ap, fmt);
|
||
NSLogv(fmt, ap);
|
||
va_end(ap);
|
||
}
|
||
|
||
- (unsigned int) debugging
|
||
{
|
||
return _debugging;
|
||
}
|
||
|
||
- (NSTimeInterval) durationLogging
|
||
{
|
||
return _duration;
|
||
}
|
||
|
||
- (void) setDebugging: (unsigned int)level
|
||
{
|
||
_debugging = level;
|
||
}
|
||
|
||
- (void) setDurationLogging: (NSTimeInterval)threshold
|
||
{
|
||
_duration = threshold;
|
||
}
|
||
|
||
@end
|
||
|
||
/* Containers for all instances.
|
||
* Access to and update of these containers is protected by classLock.
|
||
* Most other operations involving an instance are protected by a lock
|
||
* in that instance.
|
||
* To avoid deadlocks, we always obtain the instance lock *before* we
|
||
* obtain the class lock, so we don't get the situation where one thread
|
||
* has locked the instance and another has locked the class lock, and
|
||
* each thread then tries to get the other lock.
|
||
*/
|
||
static NSHashTable *clientsHash = 0;
|
||
static NSMapTable *clientsMap = 0;
|
||
static NSRecursiveLock *clientsLock = nil;
|
||
|
||
/* Protect changes to the cache used for queries by any individual client.
|
||
*/
|
||
static NSRecursiveLock *cacheLock = nil;
|
||
|
||
static NSString *beginString = @"begin";
|
||
static NSArray *beginStatement = nil;
|
||
static NSString *commitString = @"commit";
|
||
static NSArray *commitStatement = nil;
|
||
static NSString *rollbackString = @"rollback";
|
||
static NSArray *rollbackStatement = nil;
|
||
|
||
|
||
@interface SQLClient (Private)
|
||
|
||
/* Takes the timestamp of the end of the operation and checks how long
|
||
* the operation took, returning a string containing a message to be
|
||
* logged if the threshold was exceeded.
|
||
* The message contains the total duration with a separate breakdown
|
||
* of connection and pool lock wait times if they are a millisecond
|
||
* or longer.
|
||
*/
|
||
- (NSMutableString*) _checkDuration: (NSTimeInterval)end;
|
||
|
||
/**
|
||
* Internal method to handle configuration using the notification object.
|
||
* This object may be either a configuration front end or a user defaults
|
||
* object ... so we have to be careful that we work with both.
|
||
*/
|
||
- (void) _configure: (NSNotification*)n;
|
||
|
||
/** Internal method to make the client instance lock available to
|
||
* an associated SQLTransaction
|
||
*/
|
||
- (NSRecursiveLock*) _lock;
|
||
|
||
/** Internal method to populate the cache with the result of a query.
|
||
*/
|
||
- (void) _populateCache: (CacheQuery*)a;
|
||
|
||
/** Internal method called to record the 'main' thread in which automated
|
||
* cache updates are to be performed.
|
||
*/
|
||
- (void) _recordMainThread;
|
||
|
||
/*
|
||
* Called at one second intervals to ensure that our current timestamp
|
||
* is reasonably accurate.
|
||
*/
|
||
+ (void) _tick: (NSTimer*)t;
|
||
|
||
@end
|
||
|
||
@interface SQLClient (GSCacheDelegate)
|
||
- (BOOL) shouldKeepItem: (id)anObject
|
||
withKey: (id)aKey
|
||
lifetime: (unsigned)lifetime
|
||
after: (unsigned)delay;
|
||
@end
|
||
|
||
@implementation SQLClient
|
||
|
||
static NSTimeInterval abandonAfter = 0.0;
|
||
static unsigned int maxConnections = 8;
|
||
static int poolConnections = 0;
|
||
|
||
+ (NSArray*) allClients
|
||
{
|
||
NSMutableArray *a;
|
||
NSHashEnumerator e;
|
||
id o;
|
||
|
||
[clientsLock lock];
|
||
a = [NSMutableArray arrayWithCapacity: NSCountHashTable(clientsHash)];
|
||
e = NSEnumerateHashTable(clientsHash);
|
||
while (nil != (o = (id)NSNextHashEnumeratorItem(&e)))
|
||
{
|
||
[a addObject: o];
|
||
}
|
||
NSEndHashTableEnumeration(&e);
|
||
[clientsLock unlock];
|
||
return a;
|
||
}
|
||
|
||
+ (SQLClient*) clientWithConfiguration: (NSDictionary*)config
|
||
name: (NSString*)reference
|
||
{
|
||
SQLClient *o;
|
||
|
||
if ([reference isKindOfClass: NSStringClass] == NO)
|
||
{
|
||
if (nil == config)
|
||
{
|
||
config = (NSDictionary*)[NSUserDefaults standardUserDefaults];
|
||
}
|
||
reference = [config objectForKey: @"SQLClientName"];
|
||
if ([reference isKindOfClass: NSStringClass] == NO)
|
||
{
|
||
reference = @"Database";
|
||
}
|
||
}
|
||
|
||
o = [self existingClient: reference];
|
||
if (nil == o)
|
||
{
|
||
o = [[[SQLClient alloc] initWithConfiguration: config name: reference]
|
||
autorelease];
|
||
}
|
||
else if ([config isKindOfClass: [NSUserDefaults class]] == NO)
|
||
{
|
||
/* If the configuration object is not the user defaults
|
||
* make sure to update the existing connnection's configuration.
|
||
*/
|
||
NSNotification *n = [NSNotification
|
||
notificationWithName: NSUserDefaultsDidChangeNotification
|
||
object: config
|
||
userInfo: nil];
|
||
[o _configure: n];
|
||
}
|
||
|
||
return o;
|
||
}
|
||
|
||
+ (SQLClient*) existingClient: (NSString*)reference
|
||
{
|
||
SQLClient *existing;
|
||
|
||
if ([reference isKindOfClass: NSStringClass] == NO)
|
||
{
|
||
reference = [[NSUserDefaults standardUserDefaults] stringForKey:
|
||
@"SQLClientName"];
|
||
if (reference == nil)
|
||
{
|
||
reference = @"Database";
|
||
}
|
||
}
|
||
|
||
[clientsLock lock];
|
||
existing = (SQLClient*)NSMapGet(clientsMap, reference);
|
||
[[existing retain] autorelease];
|
||
[clientsLock unlock];
|
||
return existing;
|
||
}
|
||
|
||
+ (void) initialize
|
||
{
|
||
if (Nil == SQLClientClass && [SQLClient class] == self)
|
||
{
|
||
static id modes[1];
|
||
|
||
if (Nil == LitStringClass)
|
||
{
|
||
/* Find the literal string class used by the foundation library.
|
||
* We may have two varieties.
|
||
*/
|
||
LitStringClass = object_getClass(@"test string");
|
||
TinyStringClass = object_getClass(@"test");
|
||
|
||
SQLStringClass = [SQLString class];
|
||
SQLStringSize = class_getInstanceSize(SQLStringClass);
|
||
LitProxyClass = [SQLLiteralProxy class];
|
||
}
|
||
|
||
if (nil == null)
|
||
{
|
||
null = [NSNull new];
|
||
}
|
||
SQLClientClass = self;
|
||
modes[0] = NSDefaultRunLoopMode;
|
||
queryModes = [[NSArray alloc] initWithObjects: modes count: 1];
|
||
GSTickerTimeNow();
|
||
[SQLRecord class]; // Force initialisatio
|
||
if (0 == clientsHash)
|
||
{
|
||
cacheLock = [NSRecursiveLock new];
|
||
clientsHash = NSCreateHashTable(NSNonOwnedPointerHashCallBacks, 0);
|
||
clientsMap = NSCreateMapTable(NSObjectMapKeyCallBacks,
|
||
NSNonRetainedObjectMapValueCallBacks, 0);
|
||
clientsLock = [NSRecursiveLock new];
|
||
beginStatement = [[NSArray arrayWithObject: beginString] retain];
|
||
commitStatement = [[NSArray arrayWithObject: commitString] retain];
|
||
rollbackStatement
|
||
= [[NSArray arrayWithObject: rollbackString] retain];
|
||
NSStringClass = [NSString class];
|
||
NSDateClass = [NSDate class];
|
||
NSArrayClass = [NSArray class];
|
||
NSSetClass = [NSSet class];
|
||
[NSTimer scheduledTimerWithTimeInterval: 1.0
|
||
target: self
|
||
selector: @selector(_tick:)
|
||
userInfo: 0
|
||
repeats: YES];
|
||
}
|
||
}
|
||
}
|
||
|
||
+ (unsigned int) maxConnections
|
||
{
|
||
return maxConnections;
|
||
}
|
||
|
||
+ (void) purgeConnections: (NSDate*)since
|
||
{
|
||
NSHashEnumerator e;
|
||
NSMutableArray *a = nil;
|
||
SQLClient *o;
|
||
unsigned int connectionCount = 0;
|
||
NSTimeInterval t;
|
||
|
||
t = (nil == since) ? 0.0 : [since timeIntervalSinceReferenceDate];
|
||
|
||
/* Find clients we may want to disconnect.
|
||
*/
|
||
[clientsLock lock];
|
||
e = NSEnumerateHashTable(clientsHash);
|
||
while (nil != (o = (SQLClient*)NSNextHashEnumeratorItem(&e)))
|
||
{
|
||
if (YES == o->connected)
|
||
{
|
||
connectionCount++;
|
||
if (since != nil)
|
||
{
|
||
NSTimeInterval when = o->_lastOperation;
|
||
|
||
if (when < o->_lastStart)
|
||
{
|
||
when = o->_lastStart;
|
||
}
|
||
if (when < t)
|
||
{
|
||
if (nil == a)
|
||
{
|
||
a = [NSMutableArray array];
|
||
}
|
||
[a addObject: o];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
NSEndHashTableEnumeration(&e);
|
||
[clientsLock unlock];
|
||
|
||
/* Disconnect any clients idle too long
|
||
*/
|
||
while ([a count] > 0)
|
||
{
|
||
o = [a lastObject];
|
||
if ([o->lock tryLock])
|
||
{
|
||
if (YES == o->connected)
|
||
{
|
||
NSTimeInterval when = o->_lastOperation;
|
||
|
||
if (when < o->_lastStart)
|
||
{
|
||
when = o->_lastStart;
|
||
}
|
||
if (when < t)
|
||
{
|
||
NS_DURING
|
||
{
|
||
[o disconnect];
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
NSLog(@"Problem disconnecting: %@", localException);
|
||
}
|
||
NS_ENDHANDLER
|
||
}
|
||
}
|
||
if (NO == o->connected)
|
||
{
|
||
connectionCount--;
|
||
}
|
||
[o->lock unlock];
|
||
}
|
||
[a removeLastObject];
|
||
}
|
||
|
||
while (connectionCount >= (maxConnections + poolConnections))
|
||
{
|
||
SQLClient *other = nil;
|
||
NSTimeInterval oldest = 0.0;
|
||
|
||
connectionCount = 0;
|
||
[clientsLock lock];
|
||
e = NSEnumerateHashTable(clientsHash);
|
||
while (nil != (o = (SQLClient*)NSNextHashEnumeratorItem(&e)))
|
||
{
|
||
if (YES == o->connected)
|
||
{
|
||
NSTimeInterval when = o->_lastOperation;
|
||
|
||
if (when < o->_lastStart)
|
||
{
|
||
when = o->_lastStart;
|
||
}
|
||
connectionCount++;
|
||
if (oldest == 0.0 || when < oldest)
|
||
{
|
||
oldest = when;
|
||
ASSIGN(other, o);
|
||
}
|
||
}
|
||
}
|
||
NSEndHashTableEnumeration(&e);
|
||
[clientsLock unlock];
|
||
connectionCount--;
|
||
if ([other debugging] > 0)
|
||
{
|
||
[other debug:
|
||
@"Force disconnect of '%@' because max connections (%u) reached",
|
||
other, maxConnections];
|
||
}
|
||
[AUTORELEASE(other) disconnect];
|
||
}
|
||
}
|
||
|
||
+ (void) setAbandonFailedConnectionsAfter: (NSTimeInterval)delay
|
||
{
|
||
abandonAfter = delay;
|
||
}
|
||
|
||
+ (void) setMaxConnections: (unsigned int)c
|
||
{
|
||
if (c > 0)
|
||
{
|
||
maxConnections = c;
|
||
[self purgeConnections: nil];
|
||
}
|
||
}
|
||
|
||
- (void) begin
|
||
{
|
||
[lock lock];
|
||
if (_inTransaction == NO)
|
||
{
|
||
NS_DURING
|
||
{
|
||
[self simpleExecute: beginStatement];
|
||
_inTransaction = YES;
|
||
/* NB. We leave the lock locked ... until a matching -commit
|
||
* or -rollback is called. This prevents other threads from
|
||
* interfering with this transaction.
|
||
*/
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[lock unlock];
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
}
|
||
else
|
||
{
|
||
[lock unlock];
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"begin used inside transaction"];
|
||
}
|
||
}
|
||
|
||
- (SQLLiteral*) buildQuery: (NSString*)stmt, ...
|
||
{
|
||
va_list ap;
|
||
NSString *sql = nil;
|
||
|
||
/*
|
||
* First check validity and concatenate parts of the query.
|
||
*/
|
||
va_start (ap, stmt);
|
||
sql = [[self prepare: stmt args: ap] objectAtIndex: 0];
|
||
va_end (ap);
|
||
|
||
if ([sql length] < 1000)
|
||
{
|
||
return SQLClientMakeLiteral(sql);
|
||
}
|
||
return SQLClientProxyLiteral(sql);
|
||
}
|
||
|
||
- (SQLLiteral*) buildQuery: (NSString*)stmt with: (NSDictionary*)values
|
||
{
|
||
NSString *sql = nil;
|
||
|
||
sql = [[self prepare: stmt with: values] objectAtIndex: 0];
|
||
|
||
if ([sql length] < 1000)
|
||
{
|
||
return SQLClientMakeLiteral(sql);
|
||
}
|
||
return SQLClientProxyLiteral(sql);
|
||
}
|
||
|
||
- (NSString*) clientName
|
||
{
|
||
NSString *s;
|
||
|
||
[lock lock];
|
||
if (nil == _client)
|
||
{
|
||
_client = [[[NSProcessInfo processInfo] globallyUniqueString] retain];
|
||
}
|
||
s = [_client retain];
|
||
[lock unlock];
|
||
return [s autorelease];
|
||
}
|
||
|
||
- (void) commit
|
||
{
|
||
[lock lock];
|
||
if (_inTransaction == NO)
|
||
{
|
||
[lock unlock];
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"commit used outside transaction"];
|
||
}
|
||
|
||
/* Since we are in a transaction we must be doubly locked right now,
|
||
* so we unlock once, and we still have the lock (which was locked
|
||
* in the earlier call to the -begin method).
|
||
*/
|
||
[lock unlock];
|
||
_inTransaction = NO;
|
||
NS_DURING
|
||
{
|
||
[self simpleExecute: commitStatement];
|
||
[_statements removeAllObjects];
|
||
[lock unlock]; // Locked by -begin
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[_statements removeAllObjects];
|
||
[lock unlock]; // Locked by -begin
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
}
|
||
|
||
- (uint64_t) committed
|
||
{
|
||
return _committed;
|
||
}
|
||
|
||
- (BOOL) connect
|
||
{
|
||
if (NO == [self tryConnect] && abandonAfter > 0.0)
|
||
{
|
||
NSTimeInterval end;
|
||
|
||
end = [NSDate timeIntervalSinceReferenceDate] + abandonAfter;
|
||
while (NO == connected && [NSDate timeIntervalSinceReferenceDate] < end)
|
||
{
|
||
[self tryConnect];
|
||
}
|
||
}
|
||
return connected;
|
||
}
|
||
|
||
- (BOOL) connected
|
||
{
|
||
return connected;
|
||
}
|
||
|
||
- (NSString*) database
|
||
{
|
||
return _database;
|
||
}
|
||
|
||
- (void) dealloc
|
||
{
|
||
NSNotificationCenter *nc;
|
||
|
||
nc = [NSNotificationCenter defaultCenter];
|
||
[nc removeObserver: self];
|
||
if (YES == connected) [self disconnect];
|
||
[lock release]; lock = nil;
|
||
[_client release]; _client = nil;
|
||
[_database release]; _database = nil;
|
||
[_password release]; _password = nil;
|
||
[_user release]; _user = nil;
|
||
[_name release]; _name = nil;
|
||
[_statements release]; _statements = nil;
|
||
[_cache release]; _cache = nil;
|
||
[_cacheThread release]; _cacheThread = nil;
|
||
if (0 != _observers)
|
||
{
|
||
NSNotificationCenter *nc;
|
||
NSMapEnumerator e;
|
||
NSMutableSet *n;
|
||
id o;
|
||
|
||
nc = [NSNotificationCenter defaultCenter];
|
||
e = NSEnumerateMapTable(_observers);
|
||
while (NSNextMapEnumeratorPair(&e, (void**)&o, (void**)&n) != 0)
|
||
{
|
||
NSEnumerator *ne = [n objectEnumerator];
|
||
NSString *name;
|
||
|
||
while (nil != (name = [ne nextObject]))
|
||
{
|
||
[nc removeObserver: o name: name object: nil];
|
||
}
|
||
}
|
||
NSEndMapTableEnumeration(&e);
|
||
NSFreeMapTable(_observers);
|
||
_observers = 0;
|
||
}
|
||
[_names release]; _names = 0;
|
||
[super dealloc];
|
||
}
|
||
|
||
- (NSString*) description
|
||
{
|
||
NSMutableString *s = [[NSMutableString new] autorelease];
|
||
|
||
[lock lock];
|
||
NS_DURING
|
||
{
|
||
[s appendFormat: @"Database - %@\n", [self clientName]];
|
||
[s appendFormat: @" Name - %@\n", [self name]];
|
||
[s appendFormat: @" DBase - %@\n", [self database]];
|
||
[s appendFormat: @" DB User - %@\n", [self user]];
|
||
[s appendFormat: @" Password - %@\n",
|
||
[self password] == nil ? @"unknown" : @"known"];
|
||
[s appendFormat: @" Connected - %@\n", connected ? @"yes" : @"no"];
|
||
[s appendFormat: @" Committed - %"PRIu64"\n", _committed];
|
||
[s appendFormat: @" Transaction - %@\n",
|
||
_inTransaction ? @"yes" : @"no"];
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[lock unlock];
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
[lock unlock];
|
||
return s;
|
||
}
|
||
|
||
- (void) disconnect
|
||
{
|
||
if (YES == connected)
|
||
{
|
||
NSNotificationCenter *nc;
|
||
|
||
[lock lock];
|
||
if (YES == _inTransaction)
|
||
{
|
||
/* If we are inside a transaction we must be doubly locked,
|
||
* so we do an unlock corresponding to the -begin before we
|
||
* disconnect (the disconnect implicitly rolls back the
|
||
* transaction).
|
||
*/
|
||
_inTransaction = NO;
|
||
[lock unlock];
|
||
}
|
||
if (YES == connected)
|
||
{
|
||
NS_DURING
|
||
{
|
||
[self backendDisconnect];
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[lock unlock];
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
}
|
||
[lock unlock];
|
||
nc = [NSNotificationCenter defaultCenter];
|
||
[nc postNotificationName: SQLClientDidDisconnectNotification
|
||
object: self];
|
||
}
|
||
}
|
||
|
||
- (NSInteger) execute: (NSString*)stmt, ...
|
||
{
|
||
NSArray *info;
|
||
va_list ap;
|
||
|
||
va_start (ap, stmt);
|
||
info = [self prepare: stmt args: ap];
|
||
va_end (ap);
|
||
return [self simpleExecute: info];
|
||
}
|
||
|
||
- (NSInteger) execute: (NSString*)stmt with: (NSDictionary*)values
|
||
{
|
||
NSArray *info;
|
||
|
||
info = [self prepare: stmt with: values];
|
||
return [self simpleExecute: info];
|
||
}
|
||
|
||
- (id) init
|
||
{
|
||
return [self initWithConfiguration: nil name: nil];
|
||
}
|
||
|
||
- (id) initWithConfiguration: (NSDictionary*)config
|
||
{
|
||
return [self initWithConfiguration: config name: nil];
|
||
}
|
||
|
||
- (id) initWithConfiguration: (NSDictionary*)config
|
||
name: (NSString*)reference
|
||
{
|
||
return [self initWithConfiguration: config name: reference pool: nil];
|
||
}
|
||
|
||
|
||
- (id) initWithConfiguration: (NSDictionary*)config
|
||
name: (NSString*)reference
|
||
pool: (SQLClientPool*)pool
|
||
{
|
||
NSNotification *n;
|
||
NSDictionary *conf = config;
|
||
id existing;
|
||
|
||
if (conf == nil)
|
||
{
|
||
// Pretend the defaults object is a dictionary.
|
||
conf = (NSDictionary*)[NSUserDefaults standardUserDefaults];
|
||
}
|
||
|
||
if ([reference isKindOfClass: NSStringClass] == NO)
|
||
{
|
||
reference = [conf objectForKey: @"SQLClientName"];
|
||
if ([reference isKindOfClass: NSStringClass] == NO)
|
||
{
|
||
reference = @"Database";
|
||
}
|
||
}
|
||
|
||
[clientsLock lock];
|
||
_pool = pool;
|
||
if (nil != _pool)
|
||
{
|
||
existing = nil; // Pool, object ... can't already exist
|
||
}
|
||
else
|
||
{
|
||
existing = (SQLClient*)NSMapGet(clientsMap, reference);
|
||
}
|
||
if (nil == existing)
|
||
{
|
||
lock = [NSRecursiveLock new]; // Ensure thread-safety.
|
||
[self setDebugging: [[self class] debugging]];
|
||
[self setDurationLogging: [[self class] durationLogging]];
|
||
[self setName: reference]; // Set name and store in cache.
|
||
_statements = [NSMutableArray new];
|
||
|
||
if ([conf isKindOfClass: [NSUserDefaults class]] == YES)
|
||
{
|
||
NSNotificationCenter *nc;
|
||
|
||
nc = [NSNotificationCenter defaultCenter];
|
||
[nc addObserver: self
|
||
selector: @selector(_configure:)
|
||
name: NSUserDefaultsDidChangeNotification
|
||
object: conf];
|
||
}
|
||
n = [NSNotification
|
||
notificationWithName: NSUserDefaultsDidChangeNotification
|
||
object: conf
|
||
userInfo: nil];
|
||
|
||
NSHashInsert(clientsHash, (void*)self);
|
||
[self _configure: n]; // Actually set up the configuration.
|
||
}
|
||
else
|
||
{
|
||
[self release];
|
||
self = [existing retain];
|
||
|
||
if ([conf isKindOfClass: [NSUserDefaults class]] == NO)
|
||
{
|
||
/* If the configuration object is not the user defaults
|
||
* make sure to update the existing connnection's configuration.
|
||
*/
|
||
n = [NSNotification
|
||
notificationWithName: NSUserDefaultsDidChangeNotification
|
||
object: conf
|
||
userInfo: nil];
|
||
[self _configure: n];
|
||
}
|
||
}
|
||
[clientsLock unlock];
|
||
|
||
return self;
|
||
}
|
||
|
||
- (NSUInteger) hash
|
||
{
|
||
return [[self database] hash] + [[self user] hash];
|
||
}
|
||
|
||
- (BOOL) isEqual: (id)other
|
||
{
|
||
if (self == other)
|
||
{
|
||
return YES;
|
||
}
|
||
if ([self class] != [other class])
|
||
{
|
||
return NO;
|
||
}
|
||
if (NO == [[self database] isEqual: [other database]])
|
||
{
|
||
return NO;
|
||
}
|
||
if (NO == [[self user] isEqual: [other user]])
|
||
{
|
||
return NO;
|
||
}
|
||
return YES;
|
||
}
|
||
|
||
- (BOOL) isInTransaction
|
||
{
|
||
return _inTransaction;
|
||
}
|
||
|
||
- (NSDate*) lastConnect
|
||
{
|
||
if (_lastConnect > 0.0)
|
||
{
|
||
return [NSDate dateWithTimeIntervalSinceReferenceDate: _lastConnect];
|
||
}
|
||
return nil;
|
||
}
|
||
|
||
- (NSDate*) lastOperation
|
||
{
|
||
if (_lastOperation > 0.0 && _connectFails == 0)
|
||
{
|
||
return [NSDate dateWithTimeIntervalSinceReferenceDate: _lastOperation];
|
||
}
|
||
return nil;
|
||
}
|
||
|
||
- (BOOL) lockBeforeDate: (NSDate*)limit
|
||
{
|
||
if (nil == limit)
|
||
{
|
||
return [lock tryLock];
|
||
}
|
||
return [lock lockBeforeDate: limit];
|
||
}
|
||
|
||
- (SQLClient*) longestIdle: (SQLClient*)other
|
||
{
|
||
NSTimeInterval t0;
|
||
NSTimeInterval t1;
|
||
|
||
t0 = _lastOperation;
|
||
if (t0 < _lastStart)
|
||
{
|
||
t0 = _lastStart;
|
||
}
|
||
if (NO == connected || 0 != _connectFails)
|
||
{
|
||
t0 = 0.0;
|
||
}
|
||
|
||
if (NO == [other isKindOfClass: SQLClientClass] || YES == [other isProxy])
|
||
{
|
||
t1 = 0.0;
|
||
}
|
||
else
|
||
{
|
||
t1 = other->_lastOperation;
|
||
if (t1 < other->_lastStart)
|
||
{
|
||
t1 = other->_lastStart;
|
||
}
|
||
if (NO == other->connected || 0 != other->_connectFails)
|
||
{
|
||
t1 = 0.0;
|
||
}
|
||
}
|
||
|
||
if (t1 > 0.0 && (t1 <= t0 || 0.0 == t0))
|
||
{
|
||
return other;
|
||
}
|
||
if (t0 > 0.0 && (t0 <= t1 || 0.0 == t1))
|
||
{
|
||
return self;
|
||
}
|
||
return nil;
|
||
}
|
||
|
||
- (NSString*) name
|
||
{
|
||
return _name;
|
||
}
|
||
|
||
- (NSString*) password
|
||
{
|
||
return _password;
|
||
}
|
||
|
||
- (NSMutableArray*) prepare: (NSString*)stmt, ...
|
||
{
|
||
va_list ap;
|
||
NSMutableArray *result;
|
||
|
||
va_start (ap, stmt);
|
||
result = [self prepare: stmt args: ap];
|
||
va_end (ap);
|
||
|
||
return result;
|
||
}
|
||
|
||
- (NSMutableArray*) prepare: (NSString*)stmt args: (va_list)args
|
||
{
|
||
NSMutableArray *ma = [NSMutableArray arrayWithCapacity: 2];
|
||
NSString *tmp = va_arg(args, NSString*);
|
||
NSAutoreleasePool *arp = [NSAutoreleasePool new];
|
||
|
||
if (tmp != nil)
|
||
{
|
||
NSMutableString *s = [NSMutableString stringWithCapacity: 1024];
|
||
NSString *warn = nil;
|
||
unsigned index = 0;
|
||
|
||
[s appendString: stmt];
|
||
/*
|
||
* Append any values from the nil terminated varargs
|
||
*/
|
||
while (tmp != nil)
|
||
{
|
||
index++;
|
||
if ([tmp isKindOfClass: [NSData class]] == YES)
|
||
{
|
||
[ma addObject: tmp];
|
||
tmp = @"'?'''?'"; // Marker.
|
||
}
|
||
else if ([tmp isKindOfClass: NSStringClass] == NO)
|
||
{
|
||
tmp = [self quote: tmp];
|
||
}
|
||
else
|
||
{
|
||
Class c = object_getClass(tmp);
|
||
|
||
if (c == LitProxyClass)
|
||
{
|
||
tmp = ((SQLLiteralProxy*)tmp)->content;
|
||
}
|
||
else if (c != LitStringClass
|
||
&& c != TinyStringClass
|
||
&& c != SQLStringClass)
|
||
{
|
||
if (nil == warn)
|
||
{
|
||
warn = [NSString stringWithFormat:
|
||
@"\"%@\" (argument %u, %@)",
|
||
tmp, index, NSStringFromClass(c)];
|
||
}
|
||
if (YES == autoquote)
|
||
{
|
||
tmp = [self quote: tmp];
|
||
}
|
||
}
|
||
}
|
||
[s appendString: tmp];
|
||
tmp = va_arg(args, NSString*);
|
||
}
|
||
stmt = s;
|
||
if (nil != warn && YES == autoquoteWarning)
|
||
{
|
||
if (YES == autoquote)
|
||
{
|
||
NSLog(@"SQLClient autoquote performed for %@ in \"%@\"",
|
||
warn, stmt);
|
||
}
|
||
else
|
||
{
|
||
NSLog(@"SQLClient autoquote proposed for %@ in \"%@\"",
|
||
warn, stmt);
|
||
}
|
||
}
|
||
}
|
||
[ma insertObject: SQLClientMakeLiteral(stmt) atIndex: 0];
|
||
[arp release];
|
||
return ma;
|
||
}
|
||
|
||
- (NSMutableArray*) prepare: (NSString*)stmt with: (NSDictionary*)values
|
||
{
|
||
unsigned int l = [stmt length];
|
||
NSRange r;
|
||
NSMutableArray *ma = [NSMutableArray arrayWithCapacity: 2];
|
||
NSAutoreleasePool *arp = [NSAutoreleasePool new];
|
||
|
||
if (l < 2)
|
||
{
|
||
[ma addObject: SQLClientMakeLiteral(stmt)]; // Can't contain {...}
|
||
}
|
||
else if ((r = [stmt rangeOfString: @"{"]).length == 0)
|
||
{
|
||
[ma addObject: SQLClientMakeLiteral(stmt)]; // No '{' markup
|
||
}
|
||
else if (l - r.location < 2)
|
||
{
|
||
[ma addObject: SQLClientMakeLiteral(stmt)]; // Can't contain {...}
|
||
}
|
||
else if ([stmt rangeOfString: @"}" options: NSLiteralSearch
|
||
range: NSMakeRange(r.location, l - r.location)].length == 0
|
||
&& [stmt rangeOfString: @"{{" options: NSLiteralSearch
|
||
range: NSMakeRange(0, l)].length == 0)
|
||
{
|
||
[ma addObject: SQLClientMakeLiteral(stmt)]; // No '}' or '{{'
|
||
}
|
||
else if (r.length == 0)
|
||
{
|
||
[ma addObject: SQLClientMakeLiteral(stmt)]; // Nothing to do.
|
||
}
|
||
else
|
||
{
|
||
NSMutableString *mtext = [[stmt mutableCopy] autorelease];
|
||
NSString *warn = nil;
|
||
|
||
/*
|
||
* Replace {FieldName} with the value of the field
|
||
*/
|
||
while (r.length > 0)
|
||
{
|
||
unsigned pos = r.location;
|
||
unsigned nxt;
|
||
unsigned vLength;
|
||
NSArray *a;
|
||
NSRange s;
|
||
NSString *k;
|
||
NSString *v;
|
||
NSString *alt;
|
||
id o;
|
||
unsigned i;
|
||
|
||
r.length = l - pos;
|
||
|
||
/*
|
||
* If the length of the string from the '{' onwards is less than two,
|
||
* there is nothing to do and we can end processing.
|
||
*/
|
||
if (r.length < 2)
|
||
{
|
||
break;
|
||
}
|
||
|
||
if ([mtext characterAtIndex: r.location + 1] == '{')
|
||
{
|
||
// Got '{{' ... remove one of them.
|
||
r.length = 1;
|
||
[mtext replaceCharactersInRange: r withString: @""];
|
||
l--;
|
||
r.location++;
|
||
r.length = l - r.location;
|
||
r = [mtext rangeOfString: @"{"
|
||
options: NSLiteralSearch
|
||
range: r];
|
||
continue;
|
||
}
|
||
|
||
r = [mtext rangeOfString: @"}"
|
||
options: NSLiteralSearch
|
||
range: r];
|
||
if (r.length == 0)
|
||
{
|
||
break; // No closing bracket
|
||
}
|
||
nxt = NSMaxRange(r);
|
||
r = NSMakeRange(pos, nxt - pos);
|
||
s.location = r.location + 1;
|
||
s.length = r.length - 2;
|
||
k = v = [mtext substringWithRange: s];
|
||
|
||
/*
|
||
* If the value contains a '?', it is actually in two parts,
|
||
* the first part is the field name, and the second part is
|
||
* an alternative text to be used if the value from the
|
||
* dictionary is empty.
|
||
*/
|
||
s = [v rangeOfString: @"?"];
|
||
if (s.length == 0)
|
||
{
|
||
alt = @""; // No alternative value.
|
||
}
|
||
else
|
||
{
|
||
alt = [v substringFromIndex: NSMaxRange(s)];
|
||
v = [v substringToIndex: s.location];
|
||
}
|
||
|
||
/*
|
||
* If the value we are substituting contains dots, we split it apart.
|
||
* We use the value to make a reference into the dictionary we are
|
||
* given.
|
||
*/
|
||
a = [v componentsSeparatedByString: @"."];
|
||
o = values;
|
||
for (i = 0; i < [a count]; i++)
|
||
{
|
||
NSString *k = [a objectAtIndex: i];
|
||
|
||
if ([k length] > 0)
|
||
{
|
||
o = [(NSDictionary*)o objectForKey: k];
|
||
}
|
||
}
|
||
if (o == values || o == nil)
|
||
{
|
||
v = nil; // Mo match found.
|
||
}
|
||
else
|
||
{
|
||
if ([o isKindOfClass: [NSData class]] == YES)
|
||
{
|
||
[ma addObject: o];
|
||
v = @"'?'''?'";
|
||
}
|
||
else if ([o isKindOfClass: NSStringClass] == NO)
|
||
{
|
||
v = [self quote: o];
|
||
}
|
||
else
|
||
{
|
||
Class c = object_getClass(o);
|
||
|
||
v = o;
|
||
if (c == LitProxyClass)
|
||
{
|
||
v = ((SQLLiteralProxy*)o)->content;
|
||
}
|
||
else if (c != LitStringClass
|
||
&& c != TinyStringClass
|
||
&& c != SQLStringClass)
|
||
{
|
||
if (nil == warn)
|
||
{
|
||
warn = [NSString stringWithFormat:
|
||
@"\"%@\" (value for \"%@\", %@)",
|
||
o, k, NSStringFromClass(c)];
|
||
}
|
||
if (YES == autoquote)
|
||
{
|
||
v = [self quote: o];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if ([v length] == 0)
|
||
{
|
||
v = alt;
|
||
if (v == nil)
|
||
{
|
||
v = @"";
|
||
}
|
||
}
|
||
vLength = [v length];
|
||
|
||
[mtext replaceCharactersInRange: r withString: v];
|
||
l += vLength; // Add length of string inserted
|
||
l -= r.length; // Remove length of string replaced
|
||
r.location += vLength;
|
||
|
||
if (r.location >= l)
|
||
{
|
||
break;
|
||
}
|
||
r.length = l - r.location;
|
||
r = [mtext rangeOfString: @"{"
|
||
options: NSLiteralSearch
|
||
range: r];
|
||
}
|
||
[ma insertObject: SQLClientProxyLiteral(mtext) atIndex: 0];
|
||
if (nil != warn && YES == autoquoteWarning)
|
||
{
|
||
if (YES == autoquote)
|
||
{
|
||
NSLog(@"SQLClient autoquote performed for %@ in \"%@\"",
|
||
warn, mtext);
|
||
}
|
||
else
|
||
{
|
||
NSLog(@"SQLClient autoquote proposed for %@ in \"%@\"",
|
||
warn, mtext);
|
||
}
|
||
}
|
||
}
|
||
[arp release];
|
||
return ma;
|
||
}
|
||
|
||
- (NSMutableArray*) query: (NSString*)stmt, ...
|
||
{
|
||
va_list ap;
|
||
NSMutableArray *result = nil;
|
||
SQLLiteral *query;
|
||
|
||
/*
|
||
* First check validity and concatenate parts of the query.
|
||
*/
|
||
va_start (ap, stmt);
|
||
query = [[self prepare: stmt args: ap] objectAtIndex: 0];
|
||
va_end (ap);
|
||
|
||
result = [self simpleQuery: query];
|
||
|
||
return result;
|
||
}
|
||
|
||
- (NSMutableArray*) query: (NSString*)stmt with: (NSDictionary*)values
|
||
{
|
||
NSMutableArray *result = nil;
|
||
SQLLiteral *query;
|
||
|
||
query = [[self prepare: stmt with: values] objectAtIndex: 0];
|
||
|
||
result = [self simpleQuery: query];
|
||
|
||
return result;
|
||
}
|
||
|
||
- (SQLLiteral*) quote: (id)obj
|
||
{
|
||
/* For a nil object, we return NULL.
|
||
*/
|
||
if (obj == nil || obj == null)
|
||
{
|
||
return (SQLLiteral*)@"NULL";
|
||
}
|
||
else if ([obj isKindOfClass: NSStringClass] == NO)
|
||
{
|
||
/* For a data object, we don't quote ... the other parts of the code
|
||
* need to know they have an NSData object and pass it on unchanged
|
||
* to the -backendExecute: method.
|
||
*/
|
||
if ([obj isKindOfClass: [NSData class]] == YES)
|
||
{
|
||
return obj;
|
||
}
|
||
|
||
SQLLiteral *tmp = [obj quoteForSQLClient: self];
|
||
if (nil == tmp)
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Attempt to SQL quote instance of unsupported class: %@",
|
||
obj];
|
||
}
|
||
return tmp;
|
||
}
|
||
|
||
/* Get a string description of the object. */
|
||
obj = [self quoteString: obj];
|
||
|
||
return obj;
|
||
}
|
||
|
||
- (SQLLiteral*) quotef: (NSString*)fmt, ...
|
||
{
|
||
va_list ap;
|
||
NSString *str;
|
||
SQLLiteral *quoted;
|
||
|
||
va_start(ap, fmt);
|
||
str = [[NSString allocWithZone: NSDefaultMallocZone()]
|
||
initWithFormat: fmt arguments: ap];
|
||
va_end(ap);
|
||
|
||
quoted = [self quoteString: str];
|
||
[str release];
|
||
return quoted;
|
||
}
|
||
|
||
- (SQLLiteral*) quoteArray: (NSArray *)a
|
||
{
|
||
NSMutableString *s;
|
||
|
||
s = [self quoteArray: a
|
||
toString: nil
|
||
quotingStrings: NO];
|
||
return SQLClientProxyLiteral(s);
|
||
}
|
||
|
||
- (SQLLiteral*) quoteArraySafe: (NSArray *)a
|
||
{
|
||
NSMutableString *s;
|
||
|
||
s = [self quoteArray: a
|
||
toString: nil
|
||
quotingStrings: YES];
|
||
return SQLClientProxyLiteral(s);
|
||
}
|
||
|
||
- (NSMutableString*) quoteArray: (NSArray *)a
|
||
toString: (NSMutableString *)s
|
||
quotingStrings: (BOOL)q
|
||
{
|
||
[NSException raise: NSGenericException
|
||
format: @"%@ not supported for this database", NSStringFromSelector(_cmd)];
|
||
return nil;
|
||
}
|
||
|
||
- (SQLLiteral*) quoteBigInteger: (int64_t)i
|
||
{
|
||
char buf[32];
|
||
unsigned len;
|
||
SQLLiteral *s;
|
||
|
||
len = sprintf(buf, "%"PRId64, i);
|
||
s = SQLClientNewLiteral(buf, len);
|
||
return [s autorelease];
|
||
}
|
||
|
||
- (SQLLiteral*) quoteBoolean: (int)i
|
||
{
|
||
return (SQLLiteral*)(i ? @"true" : @"false");
|
||
}
|
||
|
||
- (SQLLiteral*) quoteCString: (const char *)s
|
||
{
|
||
NSString *str;
|
||
SQLLiteral *quoted;
|
||
|
||
if (s == 0)
|
||
{
|
||
s = "";
|
||
}
|
||
str = [[NSString alloc] initWithCString: s];
|
||
quoted = [self quoteString: str];
|
||
[str release];
|
||
return quoted;
|
||
}
|
||
|
||
- (SQLLiteral*) quoteChar: (char)c
|
||
{
|
||
NSString *str;
|
||
SQLLiteral *quoted;
|
||
|
||
if (c == 0)
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Attempt to quote a nul character in -quoteChar:"];
|
||
}
|
||
str = [[NSString alloc] initWithFormat: @"%c", c];
|
||
quoted = [self quoteString: str];
|
||
[str release];
|
||
return quoted;
|
||
}
|
||
|
||
- (SQLLiteral*) quoteFloat: (double)f
|
||
{
|
||
char buf[32];
|
||
unsigned len;
|
||
SQLLiteral *s;
|
||
|
||
len = sprintf(buf, "%.17g", f);
|
||
s = SQLClientNewLiteral(buf, len);
|
||
return [s autorelease];
|
||
}
|
||
|
||
- (SQLLiteral*) quoteInteger: (int)i
|
||
{
|
||
char buf[32];
|
||
unsigned len;
|
||
SQLLiteral *s;
|
||
|
||
len = sprintf(buf, "%i", i);
|
||
s = SQLClientNewLiteral(buf, len);
|
||
return [s autorelease];
|
||
}
|
||
|
||
- (SQLLiteral*) quoteName: (NSString *)s
|
||
{
|
||
NSData *d = [s dataUsingEncoding: NSUTF8StringEncoding];
|
||
const char *src = (const char*)[d bytes];
|
||
char *dst;
|
||
unsigned len = [d length];
|
||
unsigned count = 2;
|
||
unsigned i;
|
||
SQLString *q;
|
||
|
||
for (i = 0; i < len; i++)
|
||
{
|
||
char c = src[i];
|
||
|
||
if ('\"' == c)
|
||
{
|
||
count++; // A quote needs to be doubled
|
||
}
|
||
if ('\0' != c)
|
||
{
|
||
count++; // A nul needs to be ignored
|
||
}
|
||
}
|
||
q = NSAllocateObject(SQLStringClass, count + 1, NSDefaultMallocZone());
|
||
dst = ((char*)(void*)q) + SQLStringSize;
|
||
q->utf8Bytes = (uint8_t*)dst;
|
||
q->byteLen = count;
|
||
*dst++ = '\"';
|
||
for (i = 0; i < len; i++)
|
||
{
|
||
char c = src[i];
|
||
|
||
if ('\"' == c)
|
||
{
|
||
*dst++ = '\"';
|
||
}
|
||
if ('\0' != c)
|
||
{
|
||
*dst++ = c;
|
||
}
|
||
}
|
||
*dst++ = '\"';
|
||
*dst = '\0';
|
||
q->charLen = lengthUTF8(q->utf8Bytes, q->byteLen, &q->ascii, &q->latin1);
|
||
return [q autorelease];
|
||
}
|
||
|
||
- (SQLLiteral*) quoteSet: (id)obj
|
||
{
|
||
NSEnumerator *enumerator = [obj objectEnumerator];
|
||
NSMutableString *ms = [NSMutableString stringWithCapacity: 100];
|
||
id value = [enumerator nextObject];
|
||
|
||
[ms appendString: @"("];
|
||
if (value != nil)
|
||
{
|
||
[ms appendString: [self quote: value]];
|
||
}
|
||
while ((value = [enumerator nextObject]) != nil)
|
||
{
|
||
[ms appendString: @","];
|
||
[ms appendString: [self quote: value]];
|
||
}
|
||
[ms appendString: @")"];
|
||
return SQLClientMakeLiteral(ms);
|
||
}
|
||
|
||
- (SQLLiteral*) quoteString: (NSString *)s
|
||
{
|
||
NSData *d = [s dataUsingEncoding: NSUTF8StringEncoding];
|
||
const char *src = (const char*)[d bytes];
|
||
char *dst;
|
||
unsigned len = [d length];
|
||
unsigned count = 2;
|
||
unsigned i;
|
||
SQLString *q;
|
||
|
||
for (i = 0; i < len; i++)
|
||
{
|
||
char c = src[i];
|
||
|
||
if ('\'' == c)
|
||
{
|
||
count++; // A quote needs to be doubled
|
||
}
|
||
if ('\0' != c)
|
||
{
|
||
count++; // A nul needs to be ignored
|
||
}
|
||
}
|
||
q = NSAllocateObject(SQLStringClass, count + 1, NSDefaultMallocZone());
|
||
dst = ((char*)(void*)q) + SQLStringSize;
|
||
q->utf8Bytes = (uint8_t*)dst;
|
||
q->byteLen = count;
|
||
*dst++ = '\'';
|
||
for (i = 0; i < len; i++)
|
||
{
|
||
char c = src[i];
|
||
|
||
if ('\'' == c)
|
||
{
|
||
*dst++ = '\'';
|
||
}
|
||
if ('\0' != c)
|
||
{
|
||
*dst++ = c;
|
||
}
|
||
}
|
||
*dst++ = '\'';
|
||
*dst = '\0';
|
||
q->charLen = lengthUTF8(q->utf8Bytes, q->byteLen, &q->ascii, &q->latin1);
|
||
return [q autorelease];
|
||
}
|
||
|
||
- (oneway void) release
|
||
{
|
||
/* We lock the table while checking, to prevent another thread
|
||
* from grabbing this object while we are checking it.
|
||
*/
|
||
[clientsLock lock];
|
||
if ([self retainCount] > 1)
|
||
{
|
||
[super release];
|
||
[clientsLock unlock];
|
||
return;
|
||
}
|
||
|
||
if (_pool)
|
||
{
|
||
/* This is the only reference to a client associated with
|
||
* a connection pool we put this client back to the pool.
|
||
*
|
||
* That being the case, we know that this thread 'owns'
|
||
* the client and it's not going to be deallocated and not
|
||
* going to have the _pool instance variable changed, so it
|
||
* is safe to unlock clientsLock before returning the client
|
||
* to the pool. This avoids a possible deadlock when a pool
|
||
* is being purged.
|
||
*
|
||
* wl 2019-05-01: The original implementation was calling this code
|
||
* when NSDecrementExtraRefCountWasZero returns YES, but
|
||
* this does not work with newer versions of the GNUstep
|
||
* Objective-C runtime nor with recent versions of Apple's
|
||
* Objective-C runtime, which both don't handle resurrection
|
||
* gracefully for objects whose retain count has become zero.
|
||
*/
|
||
[clientsLock unlock];
|
||
[_pool _swallowClient: self explicit: NO];
|
||
}
|
||
else
|
||
{
|
||
/* As we are going to deallocate the object, we first remove
|
||
* it from global tables so that no other thread will find it
|
||
* and try to use it while it is being deallocated.
|
||
*/
|
||
NSHashRemove(clientsHash, (void*)self);
|
||
if (_name != nil
|
||
&& (SQLClient*)NSMapGet(clientsMap, (void*)_name) == self)
|
||
{
|
||
NSMapRemove(clientsMap, (void*)_name);
|
||
}
|
||
[clientsLock unlock];
|
||
[super release];
|
||
}
|
||
}
|
||
|
||
- (SQLClientPool*) pool
|
||
{
|
||
return _pool;
|
||
}
|
||
|
||
- (void) rollback
|
||
{
|
||
[lock lock];
|
||
if (NO == _inTransaction)
|
||
{
|
||
[lock unlock]; // Not in a transaction ... nothing to do.
|
||
return;
|
||
}
|
||
|
||
/* Since we are in a transaction we must be doubly locked right now,
|
||
* so we unlock once, and we still have the lock (which was locked
|
||
* in the earlier call to the -begin method).
|
||
*/
|
||
[lock unlock];
|
||
_inTransaction = NO;
|
||
NS_DURING
|
||
{
|
||
/* If the connection was lost, the transaction has implicitly
|
||
* rolled back anyway, so we should skip the rollback statement.
|
||
*/
|
||
if (YES == [self connected])
|
||
{
|
||
[self simpleExecute: rollbackStatement];
|
||
}
|
||
[_statements removeAllObjects];
|
||
[lock unlock]; // Locked by -begin
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[_statements removeAllObjects];
|
||
[lock unlock]; // Locked by -begin
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
}
|
||
|
||
- (void) setClientName: (NSString*)s
|
||
{
|
||
[lock lock];
|
||
ASSIGNCOPY(_client, s);
|
||
[lock unlock];
|
||
}
|
||
|
||
- (void) setDatabase: (NSString*)s
|
||
{
|
||
[lock lock];
|
||
NS_DURING
|
||
{
|
||
if ([s isEqual: _database] == NO)
|
||
{
|
||
if (YES == connected)
|
||
{
|
||
[self disconnect];
|
||
}
|
||
s = [s copy];
|
||
[_database release];
|
||
_database = s;
|
||
}
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[lock unlock];
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
[lock unlock];
|
||
}
|
||
|
||
- (void) setName: (NSString*)s
|
||
{
|
||
[lock lock];
|
||
NS_DURING
|
||
{
|
||
if ([s isEqual: _name] == NO)
|
||
{
|
||
[clientsLock lock];
|
||
if (nil == _pool)
|
||
{
|
||
if (NSMapGet(clientsMap, s) != 0)
|
||
{
|
||
[clientsLock unlock];
|
||
[lock unlock];
|
||
if ([self debugging] > 0)
|
||
{
|
||
[self
|
||
debug: @"Error attempt to re-use client name %@", s];
|
||
}
|
||
NS_VOIDRETURN;
|
||
}
|
||
}
|
||
if (YES == connected)
|
||
{
|
||
[self disconnect];
|
||
}
|
||
if (_name != nil
|
||
&& (SQLClient*)NSMapGet(clientsMap, (void*)_name) == self)
|
||
{
|
||
NSMapRemove(clientsMap, (void*)_name);
|
||
}
|
||
s = [s copy];
|
||
[_name release];
|
||
_name = s;
|
||
if (nil == _client)
|
||
{
|
||
_client
|
||
= [[[NSProcessInfo processInfo] globallyUniqueString] retain];
|
||
}
|
||
if (nil == _pool && _name != nil)
|
||
{
|
||
NSMapInsert(clientsMap, (void*)_name, (void*)self);
|
||
}
|
||
[clientsLock unlock];
|
||
}
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[lock unlock];
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
[lock unlock];
|
||
}
|
||
|
||
- (void) setOptions: (NSDictionary*)o
|
||
{
|
||
return; // Abstract class does not use options
|
||
}
|
||
|
||
- (void) setPassword: (NSString*)s
|
||
{
|
||
[lock lock];
|
||
NS_DURING
|
||
{
|
||
if ([s isEqual: _password] == NO)
|
||
{
|
||
if (YES == connected)
|
||
{
|
||
[self disconnect];
|
||
}
|
||
s = [s copy];
|
||
[_password release];
|
||
_password = s;
|
||
}
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[lock unlock];
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
[lock unlock];
|
||
}
|
||
|
||
- (void) setShouldTrim: (BOOL)aFlag
|
||
{
|
||
_shouldTrim = (YES == aFlag) ? YES : NO;
|
||
}
|
||
|
||
- (void) setUser: (NSString*)s
|
||
{
|
||
[lock lock];
|
||
NS_DURING
|
||
{
|
||
if ([s isEqual: _user] == NO)
|
||
{
|
||
if (YES == connected)
|
||
{
|
||
[self disconnect];
|
||
}
|
||
s = [s copy];
|
||
[_user release];
|
||
_user = s;
|
||
}
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[lock unlock];
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
[lock unlock];
|
||
}
|
||
|
||
- (NSInteger) simpleExecute: (id)info
|
||
{
|
||
NSInteger result;
|
||
NSString *debug = nil;
|
||
BOOL done = NO;
|
||
BOOL isCommit = NO;
|
||
BOOL isRollback = NO;
|
||
NSString *statement;
|
||
NSTimeInterval wait = 0.0;
|
||
|
||
if ([info isKindOfClass: NSArrayClass] == NO)
|
||
{
|
||
if ([info isKindOfClass: NSStringClass] == NO)
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"[%@ -simpleExecute: %@ (class %@)]",
|
||
NSStringFromClass([self class]),
|
||
info,
|
||
NSStringFromClass([info class])];
|
||
}
|
||
info = [NSMutableArray arrayWithObject: info];
|
||
}
|
||
|
||
if (NO == [lock tryLock])
|
||
{
|
||
wait = GSTickerTimeNow();
|
||
[lock lock];
|
||
}
|
||
_waitLock = wait;
|
||
|
||
statement = [info objectAtIndex: 0];
|
||
|
||
/* Ensure we have a working connection.
|
||
*/
|
||
if ([self connect] == NO)
|
||
{
|
||
_waitPool = 0.0;
|
||
_waitLock = 0.0;
|
||
[lock unlock];
|
||
[NSException raise: SQLConnectionException
|
||
format: @"Unable to connect to '%@' to run statement %@",
|
||
[self name], statement];
|
||
}
|
||
|
||
if ([statement isEqualToString: commitString])
|
||
{
|
||
isCommit = YES;
|
||
}
|
||
if ([statement isEqualToString: rollbackString])
|
||
{
|
||
isRollback = YES;
|
||
}
|
||
|
||
while (NO == done)
|
||
{
|
||
debug = nil;
|
||
done = YES;
|
||
NS_DURING
|
||
{
|
||
NSMutableString *m;
|
||
|
||
_lastStart = GSTickerTimeNow();
|
||
result = [self backendExecute: info];
|
||
_lastOperation = GSTickerTimeNow();
|
||
[_statements addObject: statement];
|
||
m = [self _checkDuration: _lastOperation];
|
||
if (m)
|
||
{
|
||
if (isCommit || isRollback)
|
||
{
|
||
NSEnumerator *e = [_statements objectEnumerator];
|
||
|
||
if (isCommit)
|
||
{
|
||
[m appendString: @" for transaction commit ...\n"];
|
||
}
|
||
else
|
||
{
|
||
[m appendString: @" for transaction rollback ...\n"];
|
||
}
|
||
while ((statement = [e nextObject]) != nil)
|
||
{
|
||
[m appendFormat: @" %@;\n", statement];
|
||
}
|
||
[m appendFormat: @" affected %"PRIdPTR" record%s\n",
|
||
result, ((1 == result) ? "" : "s")];
|
||
}
|
||
else if ([self debugging] > 1)
|
||
{
|
||
/*
|
||
* For higher debug levels, we log data objects as well
|
||
* as the query string, otherwise we omit them.
|
||
*/
|
||
[m appendFormat: @" for statement %@;", info];
|
||
[m appendFormat: @" affected %"PRIdPTR" record%s",
|
||
result, ((1 == result) ? "" : "s")];
|
||
}
|
||
else
|
||
{
|
||
[m appendFormat: @" for statement %@;", statement];
|
||
[m appendFormat: @" affected %"PRIdPTR" record%s",
|
||
result, ((1 == result) ? "" : "s")];
|
||
}
|
||
debug = m;
|
||
}
|
||
if (_inTransaction == NO)
|
||
{
|
||
[_statements removeAllObjects];
|
||
_committed++;
|
||
}
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
result = -1;
|
||
if (NO == _inTransaction)
|
||
{
|
||
[_statements removeAllObjects];
|
||
if ([[localException name] isEqual: SQLConnectionException])
|
||
{
|
||
/* A connection failure while not in a transaction ...
|
||
* we can and should retry.
|
||
*/
|
||
done = NO;
|
||
if (nil != debug)
|
||
{
|
||
NSLog(@"Will retry after: %@", localException);
|
||
}
|
||
[self connect];
|
||
}
|
||
}
|
||
if (done)
|
||
{
|
||
[lock unlock];
|
||
[localException raise];
|
||
}
|
||
}
|
||
NS_ENDHANDLER
|
||
}
|
||
[lock unlock];
|
||
if (nil != debug)
|
||
{
|
||
[self debug: @"%@", debug];
|
||
}
|
||
return result;
|
||
}
|
||
|
||
- (NSMutableArray*) simpleQuery: (SQLLitArg*)stmt
|
||
{
|
||
return [self simpleQuery: stmt recordType: rClass listType: aClass];
|
||
}
|
||
|
||
- (NSMutableArray*) simpleQuery: (SQLLitArg*)stmt
|
||
recordType: (id)rtype
|
||
listType: (id)ltype
|
||
{
|
||
NSMutableArray *result = nil;
|
||
NSString *debug = nil;
|
||
BOOL done = NO;
|
||
NSTimeInterval wait = 0.0;
|
||
|
||
if (rtype == 0) rtype = rClass;
|
||
if (ltype == 0) ltype = aClass;
|
||
if (NO == [lock tryLock])
|
||
{
|
||
wait = GSTickerTimeNow();
|
||
[lock lock];
|
||
}
|
||
_waitLock = wait;
|
||
|
||
if ([self connect] == NO)
|
||
{
|
||
[lock unlock];
|
||
[NSException raise: SQLConnectionException
|
||
format: @"Unable to connect to '%@' to run query %@",
|
||
[self name], stmt];
|
||
}
|
||
while (NO == done)
|
||
{
|
||
done = YES;
|
||
NS_DURING
|
||
{
|
||
NSMutableString *m;
|
||
|
||
_lastStart = GSTickerTimeNow();
|
||
result = [self backendQuery: stmt recordType: rtype listType: ltype];
|
||
_lastOperation = GSTickerTimeNow();
|
||
m = [self _checkDuration: _lastOperation];
|
||
if (m)
|
||
{
|
||
NSUInteger count = [result count];
|
||
|
||
[m appendFormat: @" for query %@; produced %"PRIuPTR" record%s",
|
||
stmt, count, ((1 == count) ? "" : "s")];
|
||
debug = m;
|
||
}
|
||
if (_inTransaction == NO)
|
||
{
|
||
_committed++;
|
||
}
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
if (NO == _inTransaction)
|
||
{
|
||
if ([[localException name] isEqual: SQLConnectionException])
|
||
{
|
||
/* A connection failure while not in a transaction ...
|
||
* we can and should retry.
|
||
*/
|
||
done = NO;
|
||
if (nil != debug)
|
||
{
|
||
NSLog(@"Will retry after: %@", localException);
|
||
}
|
||
[self connect];
|
||
}
|
||
}
|
||
if (done)
|
||
{
|
||
[lock unlock];
|
||
[localException raise];
|
||
}
|
||
}
|
||
NS_ENDHANDLER
|
||
}
|
||
[lock unlock];
|
||
if (nil != debug)
|
||
{
|
||
[self debug: @"%@", debug];
|
||
}
|
||
return result;
|
||
}
|
||
|
||
- (BOOL) tryConnect
|
||
{
|
||
if (NO == connected)
|
||
{
|
||
NSTimeInterval wait = 0.0;
|
||
NSString *msg;
|
||
|
||
if (NO == [lock tryLock])
|
||
{
|
||
wait = GSTickerTimeNow();
|
||
[lock lock];
|
||
}
|
||
_waitLock = wait;
|
||
_lastStart = GSTickerTimeNow();
|
||
if (connected)
|
||
{
|
||
msg = [self _checkDuration: _lastStart];
|
||
if (msg)
|
||
{
|
||
[self debug: @"%@ for existing connection.", msg];
|
||
}
|
||
}
|
||
else
|
||
{
|
||
NS_DURING
|
||
{
|
||
NSTimeInterval _lastListen = 0.0;
|
||
|
||
if (_connectFails > 1)
|
||
{
|
||
NSTimeInterval delay;
|
||
NSTimeInterval elapsed;
|
||
|
||
/* If we have repeated connection failures, we enforce a
|
||
* delay of up to 30 seconds between connection attempts
|
||
* to avoid overloading the system with too frequent
|
||
* connection attempts.
|
||
*/
|
||
delay = (_connectFails < 30) ? _connectFails : 30;
|
||
elapsed = GSTickerTimeNow() - _lastOperation;
|
||
if (elapsed < delay)
|
||
{
|
||
[NSThread sleepForTimeInterval: delay - elapsed];
|
||
}
|
||
}
|
||
|
||
if (YES == [self backendConnect])
|
||
{
|
||
/* On establishing a new connection, we must restore any
|
||
* listen instructions in the backend.
|
||
*/
|
||
if (nil != _names)
|
||
{
|
||
NSEnumerator *e;
|
||
NSString *n;
|
||
|
||
_lastListen = GSTickerTimeNow();
|
||
e = [_names objectEnumerator];
|
||
while (nil != (n = [e nextObject]))
|
||
{
|
||
[self backendListen: [self quoteName: n]];
|
||
}
|
||
}
|
||
_lastConnect = GSTickerTimeNow();
|
||
msg = [self _checkDuration: _lastConnect];
|
||
_connectFails = 0;
|
||
}
|
||
else
|
||
{
|
||
_lastOperation = GSTickerTimeNow();
|
||
msg = [self _checkDuration: _lastOperation];
|
||
_connectFails++;
|
||
}
|
||
|
||
if (msg)
|
||
{
|
||
NSString *s;
|
||
|
||
if (0 == _connectFails)
|
||
{
|
||
s = @"success";
|
||
}
|
||
else
|
||
{
|
||
s = @"failure";
|
||
}
|
||
|
||
if (_lastListen > 0.0)
|
||
{
|
||
[self debug: @"%@ for connection (%@)"
|
||
@", of which %g adding observers.",
|
||
msg, s, _lastOperation - _lastListen];
|
||
}
|
||
else
|
||
{
|
||
[self debug: @"%@ for connection (%@).",
|
||
msg, s];
|
||
}
|
||
}
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
_lastOperation = GSTickerTimeNow();
|
||
_connectFails++;
|
||
[lock unlock];
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
}
|
||
[lock unlock];
|
||
if (YES == connected)
|
||
{
|
||
NSNotificationCenter *nc;
|
||
|
||
nc = [NSNotificationCenter defaultCenter];
|
||
[nc postNotificationName: SQLClientDidConnectNotification
|
||
object: self];
|
||
}
|
||
}
|
||
return connected;
|
||
}
|
||
|
||
- (void) unlock
|
||
{
|
||
[lock unlock];
|
||
}
|
||
|
||
- (NSString*) user
|
||
{
|
||
return _user;
|
||
}
|
||
|
||
@end
|
||
|
||
@implementation SQLClient (Subclass)
|
||
|
||
- (BOOL) backendConnect
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Called -%@ without backend bundle loaded",
|
||
NSStringFromSelector(_cmd)];
|
||
return NO;
|
||
}
|
||
|
||
- (void) backendDisconnect
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Called -%@ without backend bundle loaded",
|
||
NSStringFromSelector(_cmd)];
|
||
}
|
||
|
||
- (NSInteger) backendExecute: (NSArray*)info
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Called -%@ without backend bundle loaded",
|
||
NSStringFromSelector(_cmd)];
|
||
return -1;
|
||
}
|
||
|
||
- (void) backendListen: (NSString*)name
|
||
{
|
||
return;
|
||
}
|
||
|
||
- (void) backendNotify: (NSString*)name payload: (NSString*)more
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Called -%@ without backend bundle implementation",
|
||
NSStringFromSelector(_cmd)];
|
||
return;
|
||
}
|
||
|
||
- (NSMutableArray*) backendQuery: (NSString*)stmt
|
||
recordType: (id)rtype
|
||
listType: (id)ltype
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Called -%@ without backend bundle loaded",
|
||
NSStringFromSelector(_cmd)];
|
||
return nil;
|
||
}
|
||
|
||
- (void) backendUnlisten: (NSString*)name
|
||
{
|
||
return;
|
||
}
|
||
|
||
- (unsigned) copyEscapedBLOB: (NSData*)blob into: (void*)buf
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Called -%@ without backend bundle loaded",
|
||
NSStringFromSelector(_cmd)];
|
||
return 0;
|
||
}
|
||
|
||
- (const void*) insertBLOBs: (NSArray*)blobs
|
||
intoStatement: (const void*)statement
|
||
length: (unsigned)sLength
|
||
withMarker: (const void*)marker
|
||
length: (unsigned)mLength
|
||
giving: (unsigned*)result
|
||
{
|
||
unsigned count = [blobs count];
|
||
unsigned length = sLength;
|
||
|
||
if (count > 1)
|
||
{
|
||
unsigned i;
|
||
unsigned char *buf;
|
||
unsigned char *ptr;
|
||
const unsigned char *from = (const unsigned char*)statement;
|
||
|
||
/*
|
||
* Calculate length of buffer needed.
|
||
*/
|
||
for (i = 1; i < count; i++)
|
||
{
|
||
length += [self lengthOfEscapedBLOB: [blobs objectAtIndex: i]];
|
||
length -= mLength;
|
||
}
|
||
|
||
buf = NSZoneMalloc(NSDefaultMallocZone(), length + 1);
|
||
[NSData dataWithBytesNoCopy: buf length: length + 1]; // autoreleased
|
||
ptr = buf;
|
||
|
||
/*
|
||
* Merge quoted data objects into statement.
|
||
*/
|
||
i = 1;
|
||
from = (unsigned char*)statement;
|
||
while (*from != 0)
|
||
{
|
||
if (*from == *(unsigned char*)marker
|
||
&& memcmp(from, marker, mLength) == 0)
|
||
{
|
||
NSData *d = [blobs objectAtIndex: i++];
|
||
|
||
from += mLength;
|
||
ptr += [self copyEscapedBLOB: d into: ptr];
|
||
}
|
||
else
|
||
{
|
||
*ptr++ = *from++;
|
||
}
|
||
}
|
||
*ptr = '\0';
|
||
statement = buf;
|
||
}
|
||
*result = length;
|
||
return statement;
|
||
}
|
||
|
||
- (unsigned) lengthOfEscapedBLOB: (NSData*)blob
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Called -%@ without backend bundle loaded",
|
||
NSStringFromSelector(_cmd)];
|
||
return 0;
|
||
}
|
||
@end
|
||
|
||
@implementation SQLClient (Private)
|
||
|
||
- (NSMutableString*) _checkDuration: (NSTimeInterval)end
|
||
{
|
||
NSMutableString *m = nil;
|
||
NSTimeInterval ti = _lastStart;
|
||
|
||
if (_waitLock > 0.0 && _waitLock < ti)
|
||
{
|
||
ti = _waitLock;
|
||
}
|
||
if (_waitPool > 0.0 && _waitPool < ti)
|
||
{
|
||
ti = _waitPool;
|
||
}
|
||
ti = end - ti; // Total duration
|
||
|
||
if (ti > _duration)
|
||
{
|
||
BOOL additional = NO;
|
||
NSTimeInterval threshold = 0.001;
|
||
|
||
/* The threshold for reporting lock information is set to zero if
|
||
* we have debug turned on or if the logging threshold is set to
|
||
* zero (to log every query). A level of zero means that any
|
||
* locjk which was not obtained immediately is recorded.
|
||
*/
|
||
if (_duration <= 0.0 || _debugging > 0.0)
|
||
{
|
||
threshold = 0.0;
|
||
}
|
||
|
||
m = [NSMutableString stringWithCapacity: 1000];
|
||
[m appendFormat: @"Duration %g", ti];
|
||
if (_waitPool > 0.0)
|
||
{
|
||
if (_waitLock > 0.0)
|
||
{
|
||
ti = _waitLock - _waitPool;
|
||
}
|
||
else
|
||
{
|
||
ti = _lastStart - _waitPool;
|
||
}
|
||
if (ti >= threshold)
|
||
{
|
||
[m appendFormat: @" (%g waiting for connection pool", ti];
|
||
additional = YES;
|
||
}
|
||
}
|
||
if (_waitLock > 0.0)
|
||
{
|
||
ti = _lastStart - _waitLock;
|
||
if (ti >= threshold)
|
||
{
|
||
if (additional)
|
||
{
|
||
[m appendFormat: @", %g waiting for connection lock", ti];
|
||
}
|
||
else
|
||
{
|
||
[m appendFormat: @" (%g waiting for connection lock", ti];
|
||
}
|
||
additional = YES;
|
||
}
|
||
}
|
||
if (additional)
|
||
{
|
||
[m appendString: @")"];
|
||
}
|
||
}
|
||
_waitPool = 0.0;
|
||
_waitLock = 0.0;
|
||
return m;
|
||
}
|
||
|
||
- (void) _configure: (NSNotification*)n
|
||
{
|
||
NSDictionary *o;
|
||
NSDictionary *d;
|
||
NSString *s;
|
||
Class c;
|
||
|
||
[lock lock];
|
||
NS_DURING
|
||
{
|
||
o = [n object];
|
||
/*
|
||
* get dictionary containing config info for this client by name.
|
||
*/
|
||
d = [o objectForKey: @"SQLClientReferences"];
|
||
if ([d isKindOfClass: [NSDictionary class]] == NO)
|
||
{
|
||
[self debug: @"Unable to find SQLClientReferences config dictionary"];
|
||
d = nil;
|
||
}
|
||
d = [d objectForKey: _name];
|
||
if ([d isKindOfClass: [NSDictionary class]] == NO)
|
||
{
|
||
[self debug: @"Unable to find config for client '%@'", _name];
|
||
d = nil;
|
||
}
|
||
|
||
s = [d objectForKey: @"ServerType"];
|
||
if ([s isKindOfClass: NSStringClass] == NO)
|
||
{
|
||
s = @"Postgres";
|
||
}
|
||
|
||
c = NSClassFromString([@"SQLClient" stringByAppendingString: s]);
|
||
if (c == nil)
|
||
{
|
||
NSString *path;
|
||
NSBundle *bundle;
|
||
NSArray *paths;
|
||
NSMutableArray *tried;
|
||
unsigned count;
|
||
|
||
paths = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory,
|
||
NSAllDomainsMask, YES);
|
||
count = [paths count];
|
||
tried = [NSMutableArray arrayWithCapacity: count];
|
||
while (count-- > 0)
|
||
{
|
||
path = [paths objectAtIndex: count];
|
||
path = [path stringByAppendingPathComponent: @"Bundles"];
|
||
path = [path stringByAppendingPathComponent:
|
||
@"SQLClient"SOVERSION""];
|
||
path = [path stringByAppendingPathComponent: s];
|
||
path = [path stringByAppendingPathExtension: @"bundle"];
|
||
bundle = [NSBundle bundleWithPath: path];
|
||
if (bundle != nil)
|
||
{
|
||
[tried addObject: path];
|
||
if ((c = [bundle principalClass]) != nil)
|
||
{
|
||
break; // Found it.
|
||
}
|
||
}
|
||
/* Try alternative version with more libraries linked in.
|
||
* In some systems and situations the dynamic linker needs
|
||
* to haved the SQLClient, gnustep-base, and objc libraries
|
||
* explicitly linked into the bundle, but in others it
|
||
* requires them to not be linked. To handle that, we create
|
||
* two versions of each bundle, the seond version has _libs
|
||
* appended to the bundle name, and has the extra libraries
|
||
* linked.
|
||
*/
|
||
path = [path stringByDeletingPathExtension];
|
||
path = [path stringByAppendingString: @"_libs"];
|
||
path = [path stringByAppendingPathExtension: @"bundle"];
|
||
bundle = [NSBundle bundleWithPath: path];
|
||
if (bundle != nil)
|
||
{
|
||
[tried addObject: path];
|
||
if ((c = [bundle principalClass]) != nil)
|
||
{
|
||
break; // Found it.
|
||
}
|
||
}
|
||
}
|
||
if (c == nil)
|
||
{
|
||
if ([tried count] == 0)
|
||
{
|
||
[self debug: @"unable to load bundle for '%@' server type"
|
||
@" ... failed to locate bundle in %@", s, paths];
|
||
}
|
||
else
|
||
{
|
||
[self debug: @"unable to load backend class for '%@' server"
|
||
@" type ... dynamic library load failed in %@", s, tried];
|
||
}
|
||
[lock unlock];
|
||
NS_VOIDRETURN;
|
||
}
|
||
}
|
||
if (c != [self class])
|
||
{
|
||
if (YES == connected)
|
||
{
|
||
[self disconnect];
|
||
}
|
||
#ifdef GNUSTEP
|
||
GSDebugAllocationRemove(object_getClass(self), self);
|
||
#endif
|
||
object_setClass(self, c);
|
||
#ifdef GNUSTEP
|
||
GSDebugAllocationAdd(object_getClass(self), self);
|
||
#endif
|
||
}
|
||
|
||
s = [d objectForKey: @"Database"];
|
||
if ([s isKindOfClass: NSStringClass] == NO)
|
||
{
|
||
s = [o objectForKey: @"Database"];
|
||
if ([s isKindOfClass: NSStringClass] == NO)
|
||
{
|
||
s = nil;
|
||
}
|
||
}
|
||
[self setDatabase: s];
|
||
|
||
s = [d objectForKey: @"User"];
|
||
if ([s isKindOfClass: NSStringClass] == NO)
|
||
{
|
||
s = [o objectForKey: @"User"];
|
||
if ([s isKindOfClass: NSStringClass] == NO)
|
||
{
|
||
s = @"";
|
||
}
|
||
}
|
||
[self setUser: s];
|
||
|
||
s = [d objectForKey: @"Password"];
|
||
if ([s isKindOfClass: NSStringClass] == NO)
|
||
{
|
||
s = [o objectForKey: @"Password"];
|
||
if ([s isKindOfClass: NSStringClass] == NO)
|
||
{
|
||
s = @"";
|
||
}
|
||
}
|
||
[self setPassword: s];
|
||
|
||
if (nil == d && [o isKindOfClass: [NSDictionary class]])
|
||
{
|
||
d = (NSDictionary*)o;
|
||
}
|
||
[self setOptions: d];
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[lock unlock];
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
[lock unlock];
|
||
}
|
||
|
||
- (NSRecursiveLock*) _lock
|
||
{
|
||
return lock;
|
||
}
|
||
|
||
- (void) _populateCache: (CacheQuery*)a
|
||
{
|
||
GSCache *cache;
|
||
id result;
|
||
|
||
result = [self simpleQuery: a->query
|
||
recordType: a->recordType
|
||
listType: a->listType];
|
||
cache = [self cache];
|
||
[cache setObject: result
|
||
forKey: a->query
|
||
lifetime: a->lifetime];
|
||
}
|
||
|
||
- (void) _recordMainThread
|
||
{
|
||
mainThread = [NSThread currentThread];
|
||
}
|
||
|
||
+ (void) _tick: (NSTimer*)t
|
||
{
|
||
(void) GSTickerTimeNow();
|
||
}
|
||
@end
|
||
|
||
@implementation SQLClient (GSCacheDelegate)
|
||
- (BOOL) shouldKeepItem: (id)anObject
|
||
withKey: (id)aKey
|
||
lifetime: (unsigned)lifetime
|
||
after: (unsigned)delay
|
||
{
|
||
CacheQuery *a;
|
||
NSDictionary *d;
|
||
|
||
a = [CacheQuery new];
|
||
aKey = [aKey copy];
|
||
[a->query release];
|
||
a->query = aKey;
|
||
d = [[NSThread currentThread] threadDictionary];
|
||
a->recordType = [d objectForKey: @"SQLClientRecordType"];
|
||
a->listType = [d objectForKey: @"SQLClientListType"];
|
||
a->lifetime = lifetime;
|
||
[a autorelease];
|
||
if (_cacheThread == nil)
|
||
{
|
||
[self _populateCache: a];
|
||
}
|
||
else
|
||
{
|
||
/* We schedule an asynchronous update if the item is not too old,
|
||
* otherwise (more than lifetime seconds past its expiry) we wait
|
||
* for the update to complete.
|
||
*/
|
||
[self performSelectorOnMainThread: @selector(_populateCache:)
|
||
withObject: a
|
||
waitUntilDone: (delay > lifetime) ? YES : NO
|
||
modes: queryModes];
|
||
}
|
||
return YES; // Always keep items ...
|
||
}
|
||
@end
|
||
|
||
|
||
|
||
@implementation SQLClient(Convenience)
|
||
|
||
+ (NSMutableArray*) columns: (NSMutableArray*)records
|
||
{
|
||
SQLRecord *r = [records lastObject];
|
||
unsigned rowCount = [records count];
|
||
unsigned colCount = [r count];
|
||
NSMutableArray *m;
|
||
|
||
if (rowCount == 0 || colCount == 0)
|
||
{
|
||
m = [NSMutableArray array];
|
||
}
|
||
else
|
||
{
|
||
NSMutableArray *cols[colCount];
|
||
unsigned i;
|
||
|
||
m = [NSMutableArray arrayWithCapacity: colCount];
|
||
for (i = 0; i < colCount; i++)
|
||
{
|
||
cols[i] = [[NSMutableArray alloc] initWithCapacity: rowCount];
|
||
[m addObject: cols[i]];
|
||
[cols[i] release];
|
||
}
|
||
for (i = 0; i < rowCount; i++)
|
||
{
|
||
unsigned j;
|
||
|
||
r = [records objectAtIndex: i];
|
||
for (j = 0; j < colCount; j++)
|
||
{
|
||
[cols[j] addObject: [r objectAtIndex: j]];
|
||
}
|
||
}
|
||
}
|
||
return m;
|
||
}
|
||
|
||
+ (void) singletons: (NSMutableArray*)records
|
||
{
|
||
unsigned c = [records count];
|
||
|
||
while (c-- > 0)
|
||
{
|
||
[records replaceObjectAtIndex: c
|
||
withObject: [[records objectAtIndex: c] lastObject]];
|
||
}
|
||
}
|
||
|
||
- (SQLTransaction*) batch: (BOOL)stopOnFailure
|
||
{
|
||
return [SQLTransaction _transactionUsing: self
|
||
batch: YES
|
||
stop: stopOnFailure];
|
||
}
|
||
|
||
- (NSMutableArray*) columns: (NSMutableArray*)records
|
||
{
|
||
return [SQLClient columns: records];
|
||
}
|
||
|
||
- (SQLRecord*) queryRecord: (NSString*)stmt, ...
|
||
{
|
||
va_list ap;
|
||
NSArray *result = nil;
|
||
SQLRecord *record;
|
||
SQLLiteral *query;
|
||
|
||
va_start (ap, stmt);
|
||
query = [[self prepare: stmt args: ap] objectAtIndex: 0];
|
||
va_end (ap);
|
||
|
||
result = [self simpleQuery: query];
|
||
|
||
if ([result count] > 1)
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Query returns more than one record -\n%@\n", query];
|
||
}
|
||
record = [result lastObject];
|
||
if (record == nil)
|
||
{
|
||
[NSException raise: SQLEmptyException
|
||
format: @"Query returns no data -\n%@\n", query];
|
||
}
|
||
return record;
|
||
}
|
||
|
||
- (NSString*) queryString: (NSString*)stmt, ...
|
||
{
|
||
va_list ap;
|
||
NSArray *result = nil;
|
||
SQLRecord *record;
|
||
SQLLiteral *query;
|
||
|
||
va_start (ap, stmt);
|
||
query = [[self prepare: stmt args: ap] objectAtIndex: 0];
|
||
va_end (ap);
|
||
|
||
result = [self simpleQuery: query];
|
||
|
||
if ([result count] > 1)
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Query returns more than one record -\n%@\n", query];
|
||
}
|
||
record = [result lastObject];
|
||
if (record == nil)
|
||
{
|
||
[NSException raise: SQLEmptyException
|
||
format: @"Query returns no data -\n%@\n", query];
|
||
}
|
||
if ([record count] > 1)
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Query returns multiple fields -\n%@\n", query];
|
||
}
|
||
return [[record lastObject] description];
|
||
}
|
||
|
||
- (void) singletons: (NSMutableArray*)records
|
||
{
|
||
[SQLClient singletons: records];
|
||
}
|
||
|
||
- (SQLTransaction*) transaction
|
||
{
|
||
return [SQLTransaction _transactionUsing: self batch: NO stop: NO];
|
||
}
|
||
|
||
@end
|
||
|
||
|
||
|
||
@interface SQLClientCacheInfo : NSObject
|
||
{
|
||
@public
|
||
NSString *query;
|
||
NSMutableArray *result;
|
||
NSTimeInterval expires;
|
||
}
|
||
@end
|
||
|
||
@implementation SQLClientCacheInfo
|
||
- (void) dealloc
|
||
{
|
||
[query release]; query = nil;
|
||
[result release]; result = nil;
|
||
[super dealloc];
|
||
}
|
||
- (NSUInteger) hash
|
||
{
|
||
return [query hash];
|
||
}
|
||
- (BOOL) isEqual: (id)other
|
||
{
|
||
return [query isEqual: ((SQLClientCacheInfo*)other)->query];
|
||
}
|
||
@end
|
||
|
||
@implementation SQLClient (Caching)
|
||
|
||
- (GSCache*) cache
|
||
{
|
||
GSCache *c;
|
||
|
||
/* NB we use a different lock to protect the cache from the lock
|
||
* used to protect the database query. That allows multiple
|
||
* connections (a connection pool) to share the same cache.
|
||
*/
|
||
[cacheLock lock];
|
||
if (nil == _cache)
|
||
{
|
||
_cache = [GSCache new];
|
||
[_cache setName: [self clientName]];
|
||
if (_cacheThread != nil)
|
||
{
|
||
[_cache setDelegate: self];
|
||
}
|
||
}
|
||
c = [_cache retain];
|
||
[cacheLock unlock];
|
||
return [c autorelease];
|
||
}
|
||
|
||
- (NSMutableArray*) cacheCheckSimpleQuery: (NSString*)stmt
|
||
{
|
||
NSMutableArray *result = [[self cache] objectForKey: stmt];
|
||
|
||
if (result != nil)
|
||
{
|
||
result = [[result mutableCopy] autorelease];
|
||
}
|
||
return result;
|
||
}
|
||
|
||
- (NSMutableArray*) cache: (int)seconds
|
||
query: (NSString*)stmt,...
|
||
{
|
||
va_list ap;
|
||
SQLLiteral *query;
|
||
|
||
va_start (ap, stmt);
|
||
query = [[self prepare: stmt args: ap] objectAtIndex: 0];
|
||
va_end (ap);
|
||
|
||
return [self cache: seconds simpleQuery: query];
|
||
}
|
||
|
||
- (NSMutableArray*) cache: (int)seconds
|
||
query: (NSString*)stmt
|
||
with: (NSDictionary*)values
|
||
{
|
||
SQLLiteral *query;
|
||
|
||
query = [[self prepare: stmt with: values] objectAtIndex: 0];
|
||
return [self cache: seconds simpleQuery: query];
|
||
}
|
||
|
||
- (NSMutableArray*) cache: (int)seconds
|
||
simpleQuery: (SQLLitArg*)stmt
|
||
{
|
||
return [self cache: seconds
|
||
simpleQuery: stmt
|
||
recordType: nil
|
||
listType: nil];
|
||
}
|
||
|
||
- (NSMutableArray*) cache: (int)seconds
|
||
simpleQuery: (SQLLitArg*)stmt
|
||
recordType: (id)rtype
|
||
listType: (id)ltype
|
||
{
|
||
NSMutableArray *result;
|
||
NSMutableDictionary *md;
|
||
GSCache *c;
|
||
id toCache;
|
||
BOOL cacheHit;
|
||
NSTimeInterval start;
|
||
NSString *s;
|
||
|
||
if (rtype == 0) rtype = rClass;
|
||
if (ltype == 0) ltype = aClass;
|
||
|
||
md = [[NSThread currentThread] threadDictionary];
|
||
[md setObject: rtype forKey: @"SQLClientRecordType"];
|
||
[md setObject: ltype forKey: @"SQLClientListType"];
|
||
start = GSTickerTimeNow();
|
||
c = [self cache];
|
||
toCache = nil;
|
||
|
||
if (seconds < 0)
|
||
{
|
||
seconds = -seconds;
|
||
result = nil;
|
||
}
|
||
else
|
||
{
|
||
result = [c objectForKey: stmt];
|
||
}
|
||
|
||
if (result == nil)
|
||
{
|
||
CacheQuery *a;
|
||
|
||
cacheHit = NO;
|
||
a = [CacheQuery new];
|
||
a->query = [stmt copy];
|
||
a->recordType = rtype;
|
||
a->listType = ltype;
|
||
a->lifetime = seconds;
|
||
[a autorelease];
|
||
|
||
if (_cacheThread == nil)
|
||
{
|
||
[self _populateCache: a];
|
||
}
|
||
else
|
||
{
|
||
/* Not really an asynchronous query because we wait until it's
|
||
* done in order to have a result we can return.
|
||
*/
|
||
[self performSelectorOnMainThread: @selector(_populateCache:)
|
||
withObject: a
|
||
waitUntilDone: YES
|
||
modes: queryModes];
|
||
}
|
||
result = [c objectForKey: stmt];
|
||
}
|
||
else
|
||
{
|
||
cacheHit = YES;
|
||
}
|
||
|
||
if (seconds == 0)
|
||
{
|
||
// We have been told to remove the existing cached item.
|
||
[c setObject: nil forKey: stmt lifetime: seconds];
|
||
toCache = nil;
|
||
}
|
||
|
||
if (toCache != nil)
|
||
{
|
||
// We have a newly retrieved object ... cache it.
|
||
[c setObject: toCache forKey: stmt lifetime: seconds];
|
||
}
|
||
|
||
if (result != nil)
|
||
{
|
||
/*
|
||
* Return an autoreleased copy ... not the original cached data.
|
||
*/
|
||
result = [[result mutableCopy] autorelease];
|
||
}
|
||
|
||
_lastStart = start;
|
||
_lastOperation = GSTickerTimeNow();
|
||
if ((s = [self _checkDuration: _lastOperation]) != nil)
|
||
{
|
||
[self debug: @"%@ for cache-%@ query %@",
|
||
s, (YES == cacheHit) ? @"hit" : @"miss", stmt];
|
||
}
|
||
return result;
|
||
}
|
||
|
||
- (void) setCache: (GSCache*)aCache
|
||
{
|
||
/* NB we use a different lock to protect the cache from the lock
|
||
* used to protect the database query. That allows multiple
|
||
* connections (a connection pool) to share the same cache.
|
||
*/
|
||
[cacheLock lock];
|
||
NS_DURING
|
||
{
|
||
if (_cacheThread != nil)
|
||
{
|
||
[_cache setDelegate: nil];
|
||
}
|
||
[aCache retain];
|
||
[_cache release];
|
||
_cache = aCache;
|
||
if (_cacheThread != nil)
|
||
{
|
||
[_cache setDelegate: self];
|
||
}
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[cacheLock unlock];
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
[cacheLock unlock];
|
||
}
|
||
|
||
- (void) setCacheThread: (NSThread*)aThread
|
||
{
|
||
if (mainThread == nil)
|
||
{
|
||
[self performSelectorOnMainThread: @selector(_recordMainThread)
|
||
withObject: nil
|
||
waitUntilDone: NO
|
||
modes: queryModes];
|
||
}
|
||
if (aThread != nil && aThread != mainThread)
|
||
{
|
||
NSLog(@"SQLClient: only the main thread is usable as cache thread");
|
||
aThread = mainThread;
|
||
}
|
||
[lock lock];
|
||
NS_DURING
|
||
{
|
||
if (_cacheThread != nil)
|
||
{
|
||
[_cache setDelegate: nil];
|
||
}
|
||
[aThread retain];
|
||
[_cacheThread release];
|
||
_cacheThread = aThread;
|
||
if (_cacheThread != nil)
|
||
{
|
||
[_cache setDelegate: self];
|
||
}
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[lock unlock];
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
[lock unlock];
|
||
}
|
||
@end
|
||
|
||
@implementation SQLTransaction
|
||
|
||
+ (SQLTransaction*) _transactionUsing: (id)clientOrPool
|
||
batch: (BOOL)isBatched
|
||
stop: (BOOL)stopOnFailure
|
||
{
|
||
SQLTransaction *transaction;
|
||
|
||
transaction = (SQLTransaction*)NSAllocateObject(self, 0,
|
||
NSDefaultMallocZone());
|
||
|
||
transaction->_owner = [clientOrPool retain];
|
||
transaction->_info = [NSMutableArray new];
|
||
transaction->_batch = isBatched;
|
||
transaction->_stop = stopOnFailure;
|
||
transaction->_lock = [NSRecursiveLock new];
|
||
return [transaction autorelease];
|
||
}
|
||
|
||
- (void) _addSQL: (NSMutableString*)sql andArgs: (NSMutableArray*)args
|
||
{
|
||
unsigned count = [_info count];
|
||
unsigned index;
|
||
|
||
for (index = 0; index < count; index++)
|
||
{
|
||
id o = [_info objectAtIndex: index];
|
||
|
||
if ([o isKindOfClass: NSArrayClass] == YES)
|
||
{
|
||
unsigned c = [(NSArray*)o count];
|
||
|
||
if (c > 0)
|
||
{
|
||
unsigned i;
|
||
|
||
[sql appendString: [(NSArray*)o objectAtIndex: 0]];
|
||
[sql appendString: @";"];
|
||
for (i = 1; i < c; i++)
|
||
{
|
||
[args addObject: [(NSArray*)o objectAtIndex: i]];
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
[(SQLTransaction*)o _addSQL: sql andArgs: args];
|
||
}
|
||
}
|
||
}
|
||
|
||
- (void) addPrepared: (NSArray*)statement
|
||
{
|
||
[_lock lock];
|
||
[_info addObject: statement];
|
||
_count++;
|
||
[_lock unlock];
|
||
}
|
||
|
||
- (void) _countLength: (unsigned*)length andArgs: (unsigned*)args
|
||
{
|
||
unsigned count = [_info count];
|
||
unsigned index;
|
||
|
||
for (index = 0; index < count; index++)
|
||
{
|
||
id o = [_info objectAtIndex: index];
|
||
|
||
if ([o isKindOfClass: NSArrayClass] == YES)
|
||
{
|
||
unsigned c = [(NSArray*)o count];
|
||
|
||
if (c > 0)
|
||
{
|
||
length += [[(NSArray*)o objectAtIndex: 0] length] + 1;
|
||
args += c - 1;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
[(SQLTransaction*)o _countLength: length andArgs: args];
|
||
}
|
||
}
|
||
}
|
||
|
||
- (void) add: (NSString*)stmt,...
|
||
{
|
||
va_list ap;
|
||
NSMutableArray *p;
|
||
|
||
va_start (ap, stmt);
|
||
p = [_owner prepare: stmt args: ap];
|
||
va_end (ap);
|
||
[self addPrepared: p];
|
||
}
|
||
|
||
- (void) add: (NSString*)stmt with: (NSDictionary*)values
|
||
{
|
||
NSMutableArray *p;
|
||
|
||
p = [_owner prepare: stmt with: values];
|
||
[self addPrepared: p];
|
||
}
|
||
|
||
- (void) append: (SQLTransaction*)other
|
||
{
|
||
if (nil == other)
|
||
{
|
||
return;
|
||
}
|
||
NSAssert(other != self, NSInvalidArgumentException);
|
||
NSAssert([other isKindOfClass: [SQLTransaction class]],
|
||
NSInvalidArgumentException);
|
||
[other lock];
|
||
[_lock lock];
|
||
NS_DURING
|
||
{
|
||
if (other->_count > 0)
|
||
{
|
||
SQLTransaction *t;
|
||
|
||
/* Owners must the the same client, or the same pool, or members
|
||
* of the same pool or a client and the pool it belongs to.
|
||
*/
|
||
if (NO == [_owner isEqual: other->_owner]
|
||
&& NO == [[_owner pool] isEqual: [other->_owner pool]])
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"[%@-%@] database owner mismatch",
|
||
NSStringFromClass([self class]), NSStringFromSelector(_cmd)];
|
||
}
|
||
|
||
t = [other copy];
|
||
|
||
[_info addObject: t];
|
||
_count += t->_count;
|
||
[t release];
|
||
}
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[_lock unlock];
|
||
[other unlock];
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
[_lock unlock];
|
||
[other unlock];
|
||
}
|
||
|
||
- (id) copyWithZone: (NSZone*)z
|
||
{
|
||
SQLTransaction *c;
|
||
|
||
[_lock lock];
|
||
c = (SQLTransaction*)NSCopyObject(self, 0, z);
|
||
c->_owner = [c->_owner retain];
|
||
c->_info = [c->_info mutableCopy];
|
||
c->_lock = [NSRecursiveLock new];
|
||
[_lock unlock];
|
||
return c;
|
||
}
|
||
|
||
- (NSUInteger) count
|
||
{
|
||
NSUInteger count;
|
||
|
||
[_lock lock];
|
||
count = [_info count];
|
||
[_lock unlock];
|
||
return count;
|
||
}
|
||
|
||
- (id) db
|
||
{
|
||
return _owner;
|
||
}
|
||
|
||
- (void) dealloc
|
||
{
|
||
[_owner release]; _owner = nil;
|
||
[_info release]; _info = nil;
|
||
[_lock release]; _lock = nil;
|
||
[super dealloc];
|
||
}
|
||
|
||
- (NSString*) description
|
||
{
|
||
NSString *str;
|
||
|
||
[_lock lock];
|
||
str = [NSString stringWithFormat: @"%@ with SQL '%@' for %@",
|
||
[super description],
|
||
(_count == 0 ? (id)@"" : (id)_info), _owner];
|
||
[_lock unlock];
|
||
return str;
|
||
}
|
||
|
||
- (void) execute
|
||
{
|
||
[_lock lock];
|
||
if (_count > 0)
|
||
{
|
||
NS_DURING
|
||
{
|
||
NSMutableArray *info = nil;
|
||
SQLClientPool *pool = nil;
|
||
SQLClient *db;
|
||
NSRecursiveLock *dbLock;
|
||
BOOL wrap;
|
||
|
||
if ([_owner isKindOfClass: [SQLClientPool class]])
|
||
{
|
||
pool = (SQLClientPool*)_owner;
|
||
db = [pool provideClient];
|
||
}
|
||
else
|
||
{
|
||
db = _owner;
|
||
}
|
||
|
||
dbLock = [db _lock];
|
||
[dbLock lock];
|
||
wrap = [db isInTransaction] ? NO : YES;
|
||
NS_DURING
|
||
{
|
||
NSMutableString *sql;
|
||
unsigned sqlSize = 0;
|
||
unsigned argCount = 0;
|
||
|
||
[self _countLength: &sqlSize andArgs: &argCount];
|
||
|
||
/* Allocate and initialise the transaction statement.
|
||
*/
|
||
info = [[NSMutableArray alloc] initWithCapacity: argCount + 1];
|
||
sql = [[NSMutableString alloc] initWithCapacity: sqlSize + 13];
|
||
[info addObject: SQLClientProxyLiteral(sql)];
|
||
[sql release];
|
||
if (YES == wrap)
|
||
{
|
||
[sql appendString: @"begin;"];
|
||
}
|
||
|
||
[self _addSQL: sql andArgs: info];
|
||
|
||
if (YES == wrap)
|
||
{
|
||
[sql appendString: @"commit;"];
|
||
}
|
||
|
||
[db simpleExecute: info];
|
||
[info release]; info = nil;
|
||
[dbLock unlock];
|
||
if (nil != pool)
|
||
{
|
||
[pool swallowClient: db];
|
||
}
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
NSException *e = localException;
|
||
|
||
[info release];
|
||
if (YES == wrap
|
||
&& NO == [[e name] isEqual: SQLConnectionException])
|
||
{
|
||
NS_DURING
|
||
{
|
||
[db simpleExecute: rollbackStatement];
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[db disconnect];
|
||
NSLog(@"Disconnected due to failed rollback after %@", e);
|
||
}
|
||
NS_ENDHANDLER
|
||
}
|
||
[dbLock unlock];
|
||
if (nil != pool)
|
||
{
|
||
[pool swallowClient: db];
|
||
}
|
||
[e raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[_lock unlock];
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
if (YES == _reset)
|
||
{
|
||
[self reset];
|
||
}
|
||
}
|
||
[_lock unlock];
|
||
}
|
||
|
||
- (unsigned) executeBatch
|
||
{
|
||
return [self executeBatchReturningFailures: nil logExceptions: NO];
|
||
}
|
||
|
||
- (unsigned) executeBatchReturningFailures: (SQLTransaction*)failures
|
||
logExceptions: (BOOL)log
|
||
{
|
||
unsigned executed = 0;
|
||
|
||
[_lock lock];
|
||
if (_count > 0)
|
||
{
|
||
NS_DURING
|
||
{
|
||
NSRecursiveLock *dbLock;
|
||
SQLClientPool *pool = nil;
|
||
SQLClient *db;
|
||
|
||
if ([_owner isKindOfClass: [SQLClientPool class]])
|
||
{
|
||
pool = (SQLClientPool*)_owner;
|
||
db = [pool provideClient];
|
||
}
|
||
else
|
||
{
|
||
db = _owner;
|
||
}
|
||
|
||
dbLock = [db _lock];
|
||
[dbLock lock];
|
||
NS_DURING
|
||
{
|
||
[self execute];
|
||
executed = _count;
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
if (log == YES || [db debugging] > 0)
|
||
{
|
||
[db debug: @"Initial failure executing batch %@: %@",
|
||
self, localException];
|
||
}
|
||
if (_batch == YES)
|
||
{
|
||
SQLTransaction *wrapper = nil;
|
||
NSUInteger count = [_info count];
|
||
NSUInteger i;
|
||
|
||
for (i = 0; i < count; i++)
|
||
{
|
||
BOOL success = NO;
|
||
id o = [_info objectAtIndex: i];
|
||
|
||
if ([o isKindOfClass: NSArrayClass] == YES)
|
||
{
|
||
NS_DURING
|
||
{
|
||
/* Wrap the statement inside a transaction so
|
||
* its context will still be that of a statement
|
||
* in a transaction rather than a standalone
|
||
* statement. This might be important if the
|
||
* statement is actually a call to a stored
|
||
* procedure whose code must all be executed
|
||
* with the visibility rules of a single
|
||
* transaction.
|
||
*/
|
||
if (wrapper == nil)
|
||
{
|
||
wrapper = [db transaction];
|
||
}
|
||
[wrapper reset];
|
||
[wrapper addPrepared: o];
|
||
[wrapper execute];
|
||
executed++;
|
||
success = YES;
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
if (failures != nil)
|
||
{
|
||
[failures addPrepared: o];
|
||
}
|
||
if (log == YES || [db debugging] > 0)
|
||
{
|
||
[db debug:
|
||
@"Failure of %d executing batch %@: %@",
|
||
i, self, localException];
|
||
}
|
||
success = NO;
|
||
}
|
||
NS_ENDHANDLER
|
||
}
|
||
else
|
||
{
|
||
unsigned result;
|
||
|
||
result = [(SQLTransaction*)o
|
||
executeBatchReturningFailures: failures
|
||
logExceptions: log];
|
||
executed += result;
|
||
if (result == [(SQLTransaction*)o totalCount])
|
||
{
|
||
success = YES;
|
||
}
|
||
}
|
||
if (success == NO && _stop == YES)
|
||
{
|
||
/* We are configured to stop after a failure,
|
||
* so we need to add all the subsequent statements
|
||
* or transactions to the list of those which have
|
||
* not been done.
|
||
*/
|
||
i++;
|
||
while (i < count)
|
||
{
|
||
id o = [_info objectAtIndex: i++];
|
||
|
||
if ([o isKindOfClass: NSArrayClass] == YES)
|
||
{
|
||
[failures addPrepared: o];
|
||
}
|
||
else
|
||
{
|
||
[failures append: (SQLTransaction*)o];
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
NS_ENDHANDLER
|
||
[dbLock unlock];
|
||
if (nil != pool)
|
||
{
|
||
[pool swallowClient: db];
|
||
}
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[_lock unlock];
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
if (YES == _reset)
|
||
{
|
||
[self reset];
|
||
}
|
||
}
|
||
[_lock unlock];
|
||
return executed;
|
||
}
|
||
|
||
- (void) insertTransaction: (SQLTransaction*)trn atIndex: (unsigned)index
|
||
{
|
||
[_lock lock];
|
||
if (index > [_info count])
|
||
{
|
||
[_lock unlock];
|
||
[NSException raise: NSRangeException
|
||
format: @"[%@-%@] index too large",
|
||
NSStringFromClass([self class]), NSStringFromSelector(_cmd)];
|
||
}
|
||
if (trn == nil || trn->_count == 0)
|
||
{
|
||
[_lock unlock];
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"[%@-%@] attempt to insert nil/empty transaction",
|
||
NSStringFromClass([self class]), NSStringFromSelector(_cmd)];
|
||
}
|
||
if (NO == [_owner isEqual: trn->_owner]
|
||
&& NO == [[_owner pool] isEqual: [trn->_owner pool]])
|
||
{
|
||
[_lock unlock];
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"[%@-%@] database owner mismatch",
|
||
NSStringFromClass([self class]), NSStringFromSelector(_cmd)];
|
||
}
|
||
trn = [trn copy];
|
||
[_info insertObject: trn atIndex: index];
|
||
_count += trn->_count;
|
||
[trn release];
|
||
[_lock unlock];
|
||
}
|
||
|
||
- (void) lock
|
||
{
|
||
[_lock lock];
|
||
}
|
||
|
||
- (id) owner
|
||
{
|
||
return _owner;
|
||
}
|
||
|
||
- (void) removeTransactionAtIndex: (unsigned)index
|
||
{
|
||
id o;
|
||
|
||
[_lock lock];
|
||
if (index >= [_info count])
|
||
{
|
||
[_lock unlock];
|
||
[NSException raise: NSRangeException
|
||
format: @"[%@-%@] index too large",
|
||
NSStringFromClass([self class]), NSStringFromSelector(_cmd)];
|
||
}
|
||
o = [_info objectAtIndex: index];
|
||
if ([o isKindOfClass: NSArrayClass] == YES)
|
||
{
|
||
_count--;
|
||
}
|
||
else
|
||
{
|
||
_count -= [(SQLTransaction*)o totalCount];
|
||
}
|
||
[_info removeObjectAtIndex: index];
|
||
[_lock unlock];
|
||
}
|
||
|
||
- (void) reset
|
||
{
|
||
[_lock lock];
|
||
[_info removeAllObjects];
|
||
_count = 0;
|
||
[_lock unlock];
|
||
}
|
||
|
||
- (BOOL) setResetOnExecute: (BOOL)aFlag
|
||
{
|
||
BOOL old;
|
||
|
||
[_lock lock];
|
||
old = _reset;
|
||
_reset = (aFlag ? YES : NO);
|
||
[_lock unlock];
|
||
return old;
|
||
}
|
||
|
||
- (unsigned) totalCount
|
||
{
|
||
return _count;
|
||
}
|
||
|
||
- (SQLTransaction*) transactionAtIndex: (unsigned)index
|
||
{
|
||
id o;
|
||
|
||
[_lock lock];
|
||
if (index >= [_info count])
|
||
{
|
||
[_lock unlock];
|
||
[NSException raise: NSRangeException
|
||
format: @"[%@-%@] index too large",
|
||
NSStringFromClass([self class]), NSStringFromSelector(_cmd)];
|
||
}
|
||
o = [_info objectAtIndex: index];
|
||
if ([o isKindOfClass: NSArrayClass] == YES)
|
||
{
|
||
SQLTransaction *t = [[self owner] transaction];
|
||
|
||
[t addPrepared: o];
|
||
[_lock unlock];
|
||
return t;
|
||
}
|
||
else
|
||
{
|
||
o = [o copy];
|
||
[_lock unlock];
|
||
return [o autorelease];
|
||
}
|
||
}
|
||
|
||
- (void) unlock
|
||
{
|
||
[_lock unlock];
|
||
}
|
||
@end
|
||
|
||
|
||
@implementation SQLClient (Notifications)
|
||
|
||
static NSString *
|
||
validName(NSString *name)
|
||
{
|
||
const char *ptr;
|
||
|
||
if (NO == [name isKindOfClass: [NSString class]])
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Notification name must be a string"];
|
||
}
|
||
ptr = [name UTF8String];
|
||
if (!isalpha(*ptr))
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Notification name must begin with letter"];
|
||
}
|
||
ptr++;
|
||
while (0 != *ptr)
|
||
{
|
||
if (!isdigit(*ptr) && !isalpha(*ptr) && *ptr != '_')
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Notification name must contain only letters,"
|
||
@" digits, and underscores"];
|
||
}
|
||
ptr++;
|
||
}
|
||
return name;
|
||
}
|
||
|
||
- (void) addObserver: (id)anObserver
|
||
selector: (SEL)aSelector
|
||
name: (NSString*)name
|
||
{
|
||
if (nil == anObserver)
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Attempt to add nil observer to SQL client"];
|
||
}
|
||
if (nil != _pool)
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Attempt to use pool client as observer"];
|
||
}
|
||
name = validName(name);
|
||
[lock lock];
|
||
NS_DURING
|
||
{
|
||
NSMutableSet *set;
|
||
|
||
if (nil == _observers)
|
||
{
|
||
_observers = NSCreateMapTable(NSNonRetainedObjectMapKeyCallBacks,
|
||
NSObjectMapValueCallBacks, 0);
|
||
_names = [NSCountedSet new];
|
||
}
|
||
set = (NSMutableSet*)NSMapGet(_observers, (void*)anObserver);
|
||
if (nil == set)
|
||
{
|
||
set = [NSMutableSet new];
|
||
NSMapInsert(_observers, anObserver, set);
|
||
[set release];
|
||
}
|
||
if (nil == [set member: name])
|
||
{
|
||
[set addObject: name];
|
||
[[NSNotificationCenter defaultCenter] addObserver: anObserver
|
||
selector: aSelector
|
||
name: name
|
||
object: self];
|
||
[_names addObject: name];
|
||
if (YES == connected && 1 == [_names countForObject: name])
|
||
{
|
||
[self backendListen: [self quoteName: name]];
|
||
}
|
||
}
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[lock unlock];
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
[lock unlock];
|
||
}
|
||
|
||
- (void) postNotificationName: (NSString*)name payload: (NSString*)more
|
||
{
|
||
name = validName(name);
|
||
if (nil != more)
|
||
{
|
||
if (NO == [more isKindOfClass: [NSString class]])
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Notification payload is not a string"];
|
||
}
|
||
}
|
||
[lock lock];
|
||
if ([self connect] == NO)
|
||
{
|
||
[lock unlock];
|
||
[NSException raise: SQLConnectionException
|
||
format: @"Unable to connect to '%@' to notify %@ with %@",
|
||
[self name], name, more];
|
||
}
|
||
NS_DURING
|
||
{
|
||
[self backendNotify: [self quoteName: name]
|
||
payload: more];
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[lock unlock];
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
[lock unlock];
|
||
}
|
||
|
||
- (void) removeObserver: (id)anObserver name: (NSString*)name
|
||
{
|
||
if (nil != name)
|
||
{
|
||
name = validName(name);
|
||
}
|
||
[lock lock];
|
||
NS_DURING
|
||
{
|
||
if (_observers != nil)
|
||
{
|
||
NSNotificationCenter *nc;
|
||
NSEnumerator *oe = nil;
|
||
|
||
nc = [NSNotificationCenter defaultCenter];
|
||
if (nil == anObserver)
|
||
{
|
||
oe = [NSAllMapTableKeys(_observers) objectEnumerator];
|
||
anObserver = [oe nextObject];
|
||
}
|
||
while (anObserver != nil)
|
||
{
|
||
NSMutableSet *set;
|
||
NSEnumerator *nameEnumerator = nil;
|
||
|
||
set = (NSMutableSet*)NSMapGet(_observers, (void*)anObserver);
|
||
if (nil == name)
|
||
{
|
||
/* Remove all names for this observer.
|
||
*/
|
||
nameEnumerator = [[set allObjects] objectEnumerator];
|
||
}
|
||
else
|
||
{
|
||
nameEnumerator
|
||
= [[NSArray arrayWithObject: name] objectEnumerator];
|
||
}
|
||
while (nil != (name = [nameEnumerator nextObject]))
|
||
{
|
||
if (nil != [set member: name])
|
||
{
|
||
[[name retain] autorelease];
|
||
[set removeObject: name];
|
||
[nc removeObserver: anObserver
|
||
name: name
|
||
object: self];
|
||
[_names removeObject: name];
|
||
if (YES == connected
|
||
&& 0 == [_names countForObject: name])
|
||
{
|
||
[self backendUnlisten: [self quoteName: name]];
|
||
}
|
||
}
|
||
}
|
||
if ([set count] == 0)
|
||
{
|
||
NSMapRemove(_observers, (void*)anObserver);
|
||
}
|
||
anObserver = [oe nextObject];
|
||
}
|
||
}
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
[lock unlock];
|
||
[localException raise];
|
||
}
|
||
NS_ENDHANDLER
|
||
[lock unlock];
|
||
}
|
||
@end
|
||
|
||
|
||
|
||
@implementation SQLDictionaryBuilder
|
||
- (void) addObject: (id)anObject
|
||
{
|
||
return;
|
||
}
|
||
|
||
- (id) alloc
|
||
{
|
||
return [self retain];
|
||
}
|
||
|
||
- (NSMutableDictionary*) content
|
||
{
|
||
return content;
|
||
}
|
||
|
||
- (NSUInteger) count
|
||
{
|
||
return [content count];
|
||
}
|
||
|
||
- (void) dealloc
|
||
{
|
||
[content release];
|
||
[super dealloc];
|
||
}
|
||
|
||
- (id) initWithCapacity: (NSUInteger)capacity
|
||
{
|
||
if (nil != (self = [super init]))
|
||
{
|
||
DESTROY(content);
|
||
content = [[NSMutableDictionary alloc] initWithCapacity: capacity];
|
||
}
|
||
return self;
|
||
}
|
||
|
||
- (id) mutableCopyWithZone: (NSZone*)aZone
|
||
{
|
||
return [content mutableCopyWithZone: aZone];
|
||
}
|
||
|
||
- (id) newWithValues: (id*)values
|
||
keys: (NSString**)keys
|
||
count: (unsigned int)count
|
||
{
|
||
if (count != 2)
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Query did not return key/value pairs"];
|
||
}
|
||
[content setObject: values[1] forKey: values[0]];
|
||
return nil;
|
||
}
|
||
@end
|
||
|
||
@implementation SQLSetBuilder
|
||
- (NSUInteger) added
|
||
{
|
||
return added;
|
||
}
|
||
|
||
- (void) addObject: (id)anObject
|
||
{
|
||
return;
|
||
}
|
||
|
||
- (id) alloc
|
||
{
|
||
return [self retain];
|
||
}
|
||
|
||
- (NSCountedSet*) content
|
||
{
|
||
return content;
|
||
}
|
||
|
||
- (NSUInteger) count
|
||
{
|
||
return [content count];
|
||
}
|
||
|
||
- (void) dealloc
|
||
{
|
||
[content release];
|
||
[super dealloc];
|
||
}
|
||
|
||
- (id) initWithCapacity: (NSUInteger)capacity
|
||
{
|
||
if (nil != (self = [super init]))
|
||
{
|
||
DESTROY(content);
|
||
content = [[NSCountedSet alloc] initWithCapacity: capacity];
|
||
added = 0;
|
||
}
|
||
return self;
|
||
}
|
||
|
||
- (id) mutableCopyWithZone: (NSZone*)aZone
|
||
{
|
||
return [content mutableCopyWithZone: aZone];
|
||
}
|
||
|
||
- (id) newWithValues: (id*)values
|
||
keys: (NSString**)keys
|
||
count: (unsigned int)count
|
||
{
|
||
if (count != 1)
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Query did not return a single value"];
|
||
}
|
||
added++;
|
||
[content addObject: values[0]];
|
||
return nil;
|
||
}
|
||
@end
|
||
|
||
@implementation SQLSingletonBuilder
|
||
- (id) newWithValues: (id*)values
|
||
keys: (NSString**)keys
|
||
count: (unsigned int)count
|
||
{
|
||
/* Instead of creating an object to hold the supplied record,
|
||
* we use the field from the record as the value to be used.
|
||
*/
|
||
if (count != 1)
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"Query did not return singleton values"];
|
||
}
|
||
return [values[0] retain];
|
||
}
|
||
@end
|
||
|
||
@implementation SQLClientPool (Adjust)
|
||
|
||
+ (void) _adjustPoolConnections: (int)n
|
||
{
|
||
unsigned err = 0;
|
||
|
||
[clientsLock lock];
|
||
poolConnections += n;
|
||
if (poolConnections < 0)
|
||
{
|
||
err -= poolConnections;
|
||
poolConnections = 0;
|
||
}
|
||
[clientsLock unlock];
|
||
NSAssert(0 == err, NSInvalidArgumentException);
|
||
}
|
||
|
||
@end
|
||
|
||
@implementation NSObject (SQLClient)
|
||
|
||
- (BOOL) isNull
|
||
{
|
||
if (nil == null)
|
||
{
|
||
null = [NSNull new];
|
||
}
|
||
return (self == null ? YES : NO);
|
||
}
|
||
|
||
- (SQLLiteral*) quoteBigInteger
|
||
{
|
||
int64_t v = (int64_t)[[self description] longLongValue];
|
||
|
||
return quoteBigInteger(v);
|
||
}
|
||
|
||
- (SQLLiteral*) quoteBigNatural
|
||
{
|
||
int64_t v = (int64_t)[[self description] longLongValue];
|
||
|
||
if (v < 0)
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Object (%@) is not a natural number", self];
|
||
}
|
||
return quoteBigInteger(v);
|
||
}
|
||
|
||
- (SQLLiteral*) quoteBigPositive
|
||
{
|
||
int64_t v = (int64_t)[[self description] longLongValue];
|
||
|
||
if (v <= 0)
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Object (%@) is not a positive number", self];
|
||
}
|
||
return quoteBigInteger(v);
|
||
}
|
||
|
||
- (SQLLiteral*) quoteBoolean
|
||
{
|
||
return (SQLLiteral*)([[self description] boolValue] ? @"true" : @"false");
|
||
}
|
||
|
||
- (SQLLiteral*) quoteForSQLClient: (SQLClient*)db
|
||
{
|
||
return nil;
|
||
}
|
||
|
||
- (SQLLiteral*) quoteInteger
|
||
{
|
||
int64_t v = (int64_t)[[self description] longLongValue];
|
||
|
||
if (v > (int64_t)2147483647LL || v < (int64_t)-2147483648LL)
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Object (%@) is not a 32bit number", self];
|
||
}
|
||
return quoteBigInteger(v);
|
||
}
|
||
|
||
- (SQLLiteral*) quoteNatural
|
||
{
|
||
int64_t v = (int64_t)[[self description] longLongValue];
|
||
|
||
if (v > (int64_t)2147483647LL || v < (int64_t)-2147483648LL)
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Object (%@) is not a 32bit number", self];
|
||
}
|
||
if (v < 0)
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Object (%@) is not a natural number", self];
|
||
}
|
||
return quoteBigInteger(v);
|
||
}
|
||
|
||
- (SQLLiteral*) quotePositive
|
||
{
|
||
int64_t v = (int64_t)[[self description] longLongValue];
|
||
|
||
if (v > (int64_t)2147483647LL || v < (int64_t)-2147483648LL)
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Object (%@) is not a 32bit number", self];
|
||
}
|
||
if (v <= 0)
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Object (%@) is not a positive number", self];
|
||
}
|
||
return quoteBigInteger(v);
|
||
}
|
||
|
||
@end
|
||
|
||
@implementation SQLClient (Quote)
|
||
|
||
+ (BOOL) autoquote
|
||
{
|
||
return autoquote;
|
||
}
|
||
|
||
+ (BOOL) autoquoteWarning
|
||
{
|
||
return autoquoteWarning;
|
||
}
|
||
|
||
+ (void) setAutoquote: (BOOL)aFlag
|
||
{
|
||
autoquote = (aFlag ? YES : NO);
|
||
}
|
||
|
||
+ (void) setAutoquoteWarning: (BOOL)aFlag
|
||
{
|
||
autoquoteWarning = (aFlag ? YES : NO);
|
||
}
|
||
|
||
@end
|
||
|
||
@implementation NSArray (Quote)
|
||
- (SQLLiteral*) quoteForSQLClient: (SQLClient*)db
|
||
{
|
||
return [db quoteSet: self];
|
||
}
|
||
@end
|
||
|
||
@implementation NSDate (Quote)
|
||
- (SQLLiteral*) quoteForSQLClient: (SQLClient*)db
|
||
{
|
||
return SQLClientMakeLiteral([self descriptionWithCalendarFormat:
|
||
@"'%Y-%m-%d %H:%M:%S.%F %z'" timeZone: nil locale: nil]);
|
||
}
|
||
@end
|
||
|
||
@implementation NSNull (Quote)
|
||
- (SQLLiteral*) quoteForSQLClient: (SQLClient*)db
|
||
{
|
||
return (SQLLiteral*)@"NULL";
|
||
}
|
||
@end
|
||
|
||
@implementation NSNumber (Quote)
|
||
- (SQLLiteral*) quoteBigInteger
|
||
{
|
||
int64_t v = (int64_t)[self longLongValue];
|
||
|
||
return quoteBigInteger(v);
|
||
}
|
||
|
||
- (SQLLiteral*) quoteBigNatural
|
||
{
|
||
int64_t v = (int64_t)[self longLongValue];
|
||
|
||
if (v < 0)
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Object (%@) is not a natural number", self];
|
||
}
|
||
return quoteBigInteger(v);
|
||
}
|
||
|
||
- (SQLLiteral*) quoteBigPositive
|
||
{
|
||
int64_t v = (int64_t)[self longLongValue];
|
||
|
||
if (v <= 0)
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Object (%@) is not a positive number", self];
|
||
}
|
||
return quoteBigInteger(v);
|
||
}
|
||
|
||
- (SQLLiteral*) quoteForSQLClient: (SQLClient*)db
|
||
{
|
||
return SQLClientMakeLiteral([self description]);
|
||
}
|
||
|
||
- (SQLLiteral*) quoteInteger
|
||
{
|
||
int64_t v = (int64_t)[self longLongValue];
|
||
|
||
if (v > (int64_t)2147483647LL || v < (int64_t)-2147483648LL)
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Object (%@) is not a 32bit number", self];
|
||
}
|
||
return quoteBigInteger(v);
|
||
}
|
||
|
||
- (SQLLiteral*) quoteNatural
|
||
{
|
||
int64_t v = (int64_t)[self longLongValue];
|
||
|
||
if (v > (int64_t)2147483647LL || v < (int64_t)-2147483648LL)
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Object (%@) is not a 32bit number", self];
|
||
}
|
||
if (v < 0)
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Object (%@) is not a natural number", self];
|
||
}
|
||
return quoteBigInteger(v);
|
||
}
|
||
|
||
- (SQLLiteral*) quotePositive
|
||
{
|
||
int64_t v = (int64_t)[self longLongValue];
|
||
|
||
if (v > (int64_t)2147483647LL || v < (int64_t)-2147483648LL)
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Object (%@) is not a 32bit number", self];
|
||
}
|
||
if (v <= 0)
|
||
{
|
||
[NSException raise: NSInternalInconsistencyException
|
||
format: @"Object (%@) is not a positive number", self];
|
||
}
|
||
return quoteBigInteger(v);
|
||
}
|
||
|
||
@end
|
||
|
||
@implementation NSSet (Quote)
|
||
- (SQLLiteral*) quoteForSQLClient: (SQLClient*)db
|
||
{
|
||
return [db quoteSet: self];
|
||
}
|
||
@end
|
||
|
||
|
||
/* Count the number of bytes that make up this UTF-8 code point.
|
||
* This to keep in mind:
|
||
* This macro doesn't return anything larger than '4'
|
||
* Legal UTF-8 cannot be larger than 4 bytes long (0x10FFFF)
|
||
* It will return 0 for anything illegal
|
||
*/
|
||
#define UTF8_BYTE_COUNT(c) \
|
||
(((c) < 0xf8) ? 1 + ((c) >= 0xc0) + ((c) >= 0xe0) + ((c) >= 0xf0) : 0)
|
||
|
||
/* Sequentially extracts characters from UTF-8 string
|
||
* p = pointer to the utf-8 data
|
||
* l = length (bytes) of the utf-8 data
|
||
* o = pointer to current offset within the data
|
||
* n = pointer to either zero or the next pre-read part of a surrogate pair.
|
||
* The condition for having read the entire string is that the offset (*o)
|
||
* is the number of bytes in the string, and the unichar pointed to by *n
|
||
* is zero (meaning there is no second part of a surrogate pair remaining).
|
||
*/
|
||
static inline unichar
|
||
nextUTF8(const uint8_t *p, unsigned l, unsigned *o, unichar *n)
|
||
{
|
||
unsigned i;
|
||
|
||
/* If we still have the second part of a surrogate pair, return it.
|
||
*/
|
||
if (*n > 0)
|
||
{
|
||
unichar u = *n;
|
||
|
||
*n = 0;
|
||
return u;
|
||
}
|
||
|
||
if ((i = *o) < l)
|
||
{
|
||
uint8_t c = p[i];
|
||
uint32_t u = c;
|
||
|
||
if (c > 0x7f)
|
||
{
|
||
int j, sle = 0;
|
||
|
||
/* calculated the expected sequence length */
|
||
sle = UTF8_BYTE_COUNT(c);
|
||
|
||
/* legal ? */
|
||
if (sle < 2)
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"bad multibyte character length"];
|
||
}
|
||
|
||
if (sle + i > l)
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"multibyte character extends beyond data"];
|
||
}
|
||
|
||
/* get the codepoint */
|
||
for (j = 1; j < sle; j++)
|
||
{
|
||
uint8_t b = p[i + j];
|
||
|
||
if (b < 0x80 || b >= 0xc0)
|
||
break;
|
||
u = (u << 6) | (b & 0x3f);
|
||
}
|
||
|
||
if (j < sle)
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"bad data in multibyte character"];
|
||
}
|
||
u = u & ~(0xffffffff << ((5 * sle) + 1));
|
||
i += sle;
|
||
|
||
/*
|
||
* We discard invalid codepoints here.
|
||
*/
|
||
if (u > 0x10ffff)
|
||
{
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"invalid unicode codepoint"];
|
||
}
|
||
}
|
||
else
|
||
{
|
||
i++;
|
||
}
|
||
|
||
/*
|
||
* Add codepoint as either a single unichar for BMP
|
||
* or as a pair of surrogates for codepoints over 16 bits.
|
||
*/
|
||
if (u >= 0x10000)
|
||
{
|
||
unichar ul, uh;
|
||
|
||
u -= 0x10000;
|
||
ul = u & 0x3ff;
|
||
uh = (u >> 10) & 0x3ff;
|
||
|
||
*n = ul + 0xdc00; // record second part of pair
|
||
u = uh + 0xd800; // return first part.
|
||
}
|
||
*o = i; // Return new index
|
||
return (unichar)u;
|
||
}
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"no more data in UTF-8 string"];
|
||
return 0;
|
||
}
|
||
|
||
@implementation SQLString
|
||
|
||
- (const char*) UTF8String
|
||
{
|
||
return (const char*)utf8Bytes;
|
||
}
|
||
|
||
- (unichar) characterAtIndex: (NSUInteger)index
|
||
{
|
||
NSUInteger l = 0;
|
||
unichar u;
|
||
unichar n = 0;
|
||
unsigned i = 0;
|
||
|
||
while (i < byteLen || n > 0)
|
||
{
|
||
u = nextUTF8(utf8Bytes, byteLen, &i, &n);
|
||
if (l++ == index)
|
||
{
|
||
return u;
|
||
}
|
||
}
|
||
|
||
[NSException raise: NSInvalidArgumentException
|
||
format: @"-characterAtIndex: index out of range"];
|
||
return 0;
|
||
}
|
||
|
||
- (BOOL) canBeConvertedToEncoding: (NSStringEncoding)encoding
|
||
{
|
||
if (NSUTF8StringEncoding == encoding
|
||
|| NSUnicodeStringEncoding == encoding
|
||
|| (NSISOLatin1StringEncoding == encoding && YES == latin1)
|
||
|| (isByteCoding(encoding) && YES == ascii))
|
||
{
|
||
return YES;
|
||
}
|
||
NS_DURING
|
||
{
|
||
id d = [self dataUsingEncoding: encoding allowLossyConversion: NO];
|
||
|
||
NS_VALRETURN(d != nil ? YES : NO);
|
||
}
|
||
NS_HANDLER
|
||
{
|
||
return NO;
|
||
}
|
||
NS_ENDHANDLER
|
||
}
|
||
|
||
- (id) copyWithZone: (NSZone*)z
|
||
{
|
||
return RETAIN(self);
|
||
}
|
||
|
||
- (NSData*) dataUsingEncoding: (NSStringEncoding)encoding
|
||
allowLossyConversion: (BOOL)flag
|
||
{
|
||
if (0 == byteLen)
|
||
{
|
||
return [NSData data];
|
||
}
|
||
|
||
if (NSUTF8StringEncoding == encoding
|
||
|| (YES == ascii && YES == isByteCoding(encoding)))
|
||
{
|
||
/* We can just copy the data unmodified
|
||
*/
|
||
return [NSData dataWithBytes: (void*)utf8Bytes
|
||
length: byteLen];
|
||
}
|
||
else if (YES == latin1 && NSISOLatin1StringEncoding == encoding)
|
||
{
|
||
unichar n = 0;
|
||
unsigned i = 0;
|
||
NSUInteger index = 0;
|
||
uint8_t *buf = malloc(charLen);
|
||
|
||
while (index < charLen && (i < byteLen || n > 0))
|
||
{
|
||
buf[index++] = nextUTF8(utf8Bytes, byteLen, &i, &n);
|
||
}
|
||
return [NSData dataWithBytesNoCopy: buf
|
||
length: charLen
|
||
freeWhenDone: YES];
|
||
}
|
||
else if (NSUnicodeStringEncoding == encoding)
|
||
{
|
||
unichar n = 0;
|
||
unsigned i = 0;
|
||
NSUInteger index = 0;
|
||
unichar *buf = malloc(charLen * sizeof(unichar));
|
||
|
||
while (index < charLen && (i < byteLen || n > 0))
|
||
{
|
||
buf[index++] = nextUTF8(utf8Bytes, byteLen, &i, &n);
|
||
}
|
||
return [NSData dataWithBytesNoCopy: buf
|
||
length: charLen * sizeof(unichar)
|
||
freeWhenDone: YES];
|
||
}
|
||
|
||
return [super dataUsingEncoding: encoding allowLossyConversion: flag];
|
||
}
|
||
|
||
- (void) getCharacters: (unichar*)buffer
|
||
range: (NSRange)aRange
|
||
{
|
||
unichar n = 0;
|
||
unsigned i = 0;
|
||
NSUInteger max = NSMaxRange(aRange);
|
||
NSUInteger index = 0;
|
||
|
||
if (NSNotFound == aRange.location)
|
||
[NSException raise: NSRangeException format:
|
||
@"in %s, range { %"PRIuPTR", %"PRIuPTR" } extends beyond string",
|
||
GSNameFromSelector(_cmd), aRange.location, aRange.length];
|
||
|
||
while (index < aRange.location && (i < byteLen || n > 0))
|
||
{
|
||
nextUTF8(utf8Bytes, byteLen, &i, &n);
|
||
index++;
|
||
}
|
||
if (index == aRange.location)
|
||
{
|
||
while (index < max && (i < byteLen || n > 0))
|
||
{
|
||
*buffer++ = nextUTF8(utf8Bytes, byteLen, &i, &n);
|
||
index++;
|
||
}
|
||
}
|
||
if (index != max)
|
||
{
|
||
[NSException raise: NSRangeException format:
|
||
@"in %s, range { %"PRIuPTR", %"PRIuPTR" } extends beyond string",
|
||
GSNameFromSelector(_cmd), aRange.location, aRange.length];
|
||
}
|
||
}
|
||
|
||
- (BOOL) getCString: (char*)buffer
|
||
maxLength: (NSUInteger)maxLength
|
||
encoding: (NSStringEncoding)encoding
|
||
{
|
||
const uint8_t *ptr = utf8Bytes;
|
||
int length = byteLen;
|
||
int index;
|
||
|
||
if (0 == maxLength || 0 == buffer)
|
||
{
|
||
return NO; // Can't fit in here
|
||
}
|
||
if (NSUTF8StringEncoding == encoding
|
||
|| (YES == ascii && isByteCoding(encoding)))
|
||
{
|
||
BOOL result = (length < maxLength) ? YES : NO;
|
||
|
||
/* We can just copy directly.
|
||
*/
|
||
if (maxLength <= length)
|
||
{
|
||
length = maxLength - 1;
|
||
}
|
||
for (index = 0; index < length; index++)
|
||
{
|
||
buffer[index] = (char)ptr[index];
|
||
}
|
||
/* Step back before any multibyte sequence
|
||
*/
|
||
while (index > 0 && (ptr[index - 1] & 0x80))
|
||
{
|
||
index--;
|
||
}
|
||
buffer[index] = '\0';
|
||
return result;
|
||
}
|
||
return [super getCString: buffer maxLength: maxLength encoding: encoding];
|
||
}
|
||
|
||
/* Must match the implementation in NSString
|
||
* To avoid allocating memory, we build the hash incrementally.
|
||
*/
|
||
- (NSUInteger) hash
|
||
{
|
||
if (NO == hasHash)
|
||
{
|
||
hash = [super hash];
|
||
hasHash = YES;
|
||
}
|
||
return hash;
|
||
}
|
||
|
||
- (id) initWithBytes: (const void*)bytes
|
||
length: (NSUInteger)length
|
||
encoding: (NSStringEncoding)encoding
|
||
{
|
||
RELEASE(self);
|
||
[NSException raise: NSGenericException
|
||
format: @"Attempt to init an SQL string"];
|
||
return nil;
|
||
}
|
||
|
||
- (id) initWithBytesNoCopy: (void*)bytes
|
||
length: (NSUInteger)length
|
||
encoding: (NSStringEncoding)encoding
|
||
freeWhenDone: (BOOL)flag
|
||
{
|
||
RELEASE(self);
|
||
[NSException raise: NSGenericException
|
||
format: @"Attempt to init an SQL string"];
|
||
return nil;
|
||
}
|
||
|
||
- (int) intValue
|
||
{
|
||
return strtol((const char*)utf8Bytes, 0, 10);
|
||
}
|
||
|
||
- (NSInteger) integerValue
|
||
{
|
||
return (NSInteger)strtoll((const char*)utf8Bytes, 0, 10);
|
||
}
|
||
|
||
- (NSUInteger) length
|
||
{
|
||
return charLen;
|
||
}
|
||
|
||
- (long long) longLongValue
|
||
{
|
||
return strtoll((const char*)utf8Bytes, 0, 10);
|
||
}
|
||
|
||
- (NSRange) rangeOfCharacterFromSet: (NSCharacterSet*)aSet
|
||
options: (NSUInteger)mask
|
||
range: (NSRange)aRange
|
||
{
|
||
NSUInteger index;
|
||
NSUInteger start;
|
||
NSUInteger stop;
|
||
NSRange range;
|
||
|
||
GS_RANGE_CHECK(aRange, charLen);
|
||
|
||
start = aRange.location;
|
||
stop = NSMaxRange(aRange);
|
||
|
||
range.location = NSNotFound;
|
||
range.length = 0;
|
||
|
||
if (stop > start)
|
||
{
|
||
BOOL (*mImp)(id, SEL, unichar);
|
||
unichar n = 0;
|
||
unsigned i = 0;
|
||
|
||
mImp = (BOOL(*)(id,SEL,unichar))
|
||
[aSet methodForSelector: @selector(characterIsMember:)];
|
||
|
||
for (index = 0; index < start; index++)
|
||
{
|
||
nextUTF8(utf8Bytes, byteLen, &i, &n);
|
||
}
|
||
if ((mask & NSBackwardsSearch) == NSBackwardsSearch)
|
||
{
|
||
unichar buf[stop - start];
|
||
NSUInteger pos = 0;
|
||
|
||
for (pos = 0; pos + start < stop; pos++)
|
||
{
|
||
buf[pos] = nextUTF8(utf8Bytes, byteLen, &i, &n);
|
||
}
|
||
index = stop;
|
||
while (index-- > start)
|
||
{
|
||
if ((*mImp)(aSet, @selector(characterIsMember:), buf[--pos]))
|
||
{
|
||
range = NSMakeRange(index, 1);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
while (index < stop)
|
||
{
|
||
unichar letter;
|
||
|
||
letter = nextUTF8(utf8Bytes, byteLen, &i, &n);
|
||
if ((*mImp)(aSet, @selector(characterIsMember:), letter))
|
||
{
|
||
range = NSMakeRange(index, 1);
|
||
break;
|
||
}
|
||
index++;
|
||
}
|
||
}
|
||
}
|
||
|
||
return range;
|
||
}
|
||
|
||
- (NSZone*) zone
|
||
{
|
||
return NSDefaultMallocZone();
|
||
}
|
||
|
||
- (NSStringEncoding) fastestEncoding
|
||
{
|
||
return NSUTF8StringEncoding;
|
||
}
|
||
|
||
- (NSStringEncoding) smallestEncoding
|
||
{
|
||
return NSUTF8StringEncoding;
|
||
}
|
||
|
||
- (NSUInteger) sizeOfContentExcluding: (NSHashTable*)exclude
|
||
{
|
||
return byteLen + 1;
|
||
}
|
||
|
||
@end
|