ObjPgSQL  Check-in [12b5ef483a]

Overview
Comment:Improve exceptions.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA3-256: 12b5ef483a1f9eae92df83cf8a6aded299ef10dd2972059a36c79d299e676a0d
User & Date: js on 2013-07-23 14:11:42
Other Links: manifest | tags
Context
2014-07-18
21:40
Adjust to ObjFW changes check-in: bec524d06b user: js tags: trunk
2013-07-23
14:11
Improve exceptions. check-in: 12b5ef483a user: js tags: trunk
2013-05-18
01:37
Add -[PGConnection close]. check-in: 52b090139e user: js tags: trunk
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Modified PGConnection.m from [81c3c0036a] to [d9f8dfd676].

︙
37
38
39
40
41
42
43
44

45
46
47
48
49
50

51
52
53
54
55
56
57

37
38
39
40
41
42
43

44

45
46
47


48
49
50
51
52
53
54
55








-
+
-



-
-
+








			[connectionInfo appendFormat: @" %@=%@", key, object];
		else
			connectionInfo = [OFMutableString stringWithFormat:
			    @"%@=%@", key, object];
	}

	if ((_connnection = PQconnectdb([connectionInfo UTF8String])) == NULL)
		@throw [OFOutOfMemoryException
		@throw [OFOutOfMemoryException exception];
		    exceptionWithClass: [self class]];

	if (PQstatus(_connnection) == CONNECTION_BAD)
		@throw [PGConnectionFailedException
		    exceptionWithClass: [self class]
			    connection: self];
		    exceptionWithConnection: self];

	[pool release];
}

- (void)reset
{
	PQreset(_connnection);
︙
68
69
70
71
72
73
74
75
76
77


78
79
80
81
82
83
84
85
86
87
88
89
90
91


92
93
94
95
96
97
98

66
67
68
69
70
71
72



73
74
75
76
77
78
79
80
81
82
83
84
85



86
87
88
89
90
91
92
93
94








-
-
-
+
+











-
-
-
+
+








- (PGResult*)executeCommand: (OFConstantString*)command
{
	PGresult *result = PQexec(_connnection, [command UTF8String]);

	if (PQresultStatus(result) == PGRES_FATAL_ERROR) {
		PQclear(result);
		@throw [PGCommandFailedException
		    exceptionWithClass: [self class]
			    connection: self
			       command: command];
		    exceptionWithConnection: self
				    command: command];
	}

	switch (PQresultStatus(result)) {
	case PGRES_TUPLES_OK:
		return [PGResult PG_resultWithResult: result];
	case PGRES_COMMAND_OK:
		PQclear(result);
		return nil;
	default:
		PQclear(result);
		@throw [PGCommandFailedException
		    exceptionWithClass: [self class]
			    connection: self
			       command: command];
		    exceptionWithConnection: self
				    command: command];
	}
}

- (PGResult*)executeCommand: (OFConstantString*)command
		 parameters: (id)parameter, ...
{
	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
︙
111
112
113
114
115
116
117


118

119
120

121
122
123
124
125
126

127
128
129
130
131
132
133

107
108
109
110
111
112
113
114
115

116
117

118
119
120
121
122
123

124
125
126
127
128
129
130
131








+
+
-
+

-
+





-
+








	@try {
		size_t i = 0;

		do {
			if ([parameter isKindOfClass: [OFString class]])
				values[i++] = [parameter UTF8String];
			else if ([parameter isKindOfClass: [OFNumber class]]) {
				OFNumber *number = parameter;

				switch ([parameter type]) {
				switch ([number type]) {
				case OF_NUMBER_BOOL:
					if ([parameter boolValue])
					if ([number boolValue])
						values[i++] = "t";
					else
						values[i++] = "f";
					break;
				default:
					values[i++] = [[parameter description]
					values[i++] = [[number description]
					    UTF8String];
					break;
				}
			} else if ([parameter isKindOfClass: [OFNull class]])
				values[i++] = NULL;
			else
				values[i++] = [[parameter description]
︙
147
148
149
150
151
152
153
154
155
156


157
158
159
160
161
162
163

145
146
147
148
149
150
151



152
153
154
155
156
157
158
159
160








-
-
-
+
+








		return [PGResult PG_resultWithResult: result];
	case PGRES_COMMAND_OK:
		PQclear(result);
		return nil;
	default:
		PQclear(result);
		@throw [PGCommandFailedException
		    exceptionWithClass: [self class]
			    connection: self
			       command: command];
		    exceptionWithConnection: self
				    command: command];
	}
}

- (void)insertRow: (OFDictionary*)row
	intoTable: (OFString*)table
{
	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
︙
210
211
212
213
214
215
216
217
218
219


220
221
222
223
224
225
226

207
208
209
210
211
212
213



214
215
216
217
218
219
220
221
222








-
-
-
+
+








	}

	[pool release];

	if (PQresultStatus(result) != PGRES_COMMAND_OK) {
		PQclear(result);
		@throw [PGCommandFailedException
		    exceptionWithClass: [self class]
			    connection: self
			       command: command];
		    exceptionWithConnection: self
				    command: command];
	}

	PQclear(result);
}

- (void)insertRows: (OFArray*)rows
	 intoTable: (OFString*)table
︙

Modified PGResult.m from [3b43b74b64] to [a066a8eda5].

︙
28
29
30
31
32
33
34
35

36
37
38
39
40
41
42
43
44
45
46

28
29
30
31
32
33
34

35

36
37
38
39
40
41
42
43
44
45








-
+
-











{
	return PQntuples(_result);
}

- (id)objectAtIndex: (size_t)index
{
	if (index > PQntuples(_result))
		@throw [OFOutOfRangeException
		@throw [OFOutOfRangeException exception];
		    exceptionWithClass: [self class]];

	return [PGResultRow rowWithResult: self
				      row: (int)index];
}

- (PGresult*)PG_result
{
	return _result;
}
@end

Modified PGResultRow.m from [bf3d3626a7] to [751cf4cc9f].

︙
120
121
122
123
124
125
126
127

128
129
130
131
132
133
134

120
121
122
123
124
125
126

127
128
129
130
131
132
133
134








-
+









	if (state->extra[0] == 0) {
		state->extra[0] = 1;
		state->extra[1] = PQnfields(_res);
	}

	if (count > SIZE_MAX - state->state)
		@throw [OFOutOfRangeException exceptionWithClass: [self class]];
		@throw [OFOutOfRangeException exception];

	if (state->state + count > state->extra[1])
		count = state->extra[1] - state->state;

	for (i = j = 0; i < count; i++) {
		if (PQgetisnull(_res, _row, state->state + i))
			continue;
︙

Modified exceptions/PGCommandFailedException.h from [bd6baa8db9] to [4d78dea5a5]. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14


15
16
17


18
19

1
2
3
4
5
6
7
8
9
10
11



12
13



14
15
16
17












-
-
-
+
+
-
-
-
+
+



#import "PGException.h"

@interface PGCommandFailedException: PGException
{
	OFString *_command;
}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, copy, nonatomic) OFString *command;
#endif

+ exceptionWithClass: (Class)class_
	  connection: (PGConnection*)connection
	     command: (OFString*)command;
+ (instancetype)exceptionWithConnection: (PGConnection*)connection
				command: (OFString*)command;
- initWithClass: (Class)class_
     connection: (PGConnection*)connection
	command: (OFString*)command;
- initWithConnection: (PGConnection*)connection
	     command: (OFString*)command;
- (OFString*)command;
@end

Modified exceptions/PGCommandFailedException.m from [6309f695e9] to [2780d9067f]. 

1
2
3
4
5
6


7
8

9
10

11
12
13
14
15


16
17

18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

40
41
42

43
44
45
46
47
48
49

1
2
3



4
5
6

7


8
9
10



11
12
13

14

15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

35



36
37
38
39
40
41
42
43




-
-
-
+
+

-
+
-
-
+


-
-
-
+
+

-
+
-




















-
+
-
-
-
+








#import "PGCommandFailedException.h"

@implementation PGCommandFailedException
+ exceptionWithClass: (Class)class
	  connection: (PGConnection*)connection
	     command: (OFString*)command
+ (instancetype)exceptionWithConnection: (PGConnection*)connection
				command: (OFString*)command
{
	return [[[self alloc] initWithClass: class
	return [[[self alloc] initWithConnection: connection
				 connection: connection
				    command: command] autorelease];
					 command: command] autorelease];
}

- initWithClass: (Class)class
     connection: (PGConnection*)connection
	command: (OFString*)command
- initWithConnection: (PGConnection*)connection
	     command: (OFString*)command
{
	self = [super initWithClass: class
	self = [super initWithConnection: connection];
			 connection: connection];

	@try {
		_command = [command copy];
	} @catch (id e) {
		[self release];
		@throw e;
	}

	return self;
}

- (void)dealloc
{
	[_command release];

	[super dealloc];
}

- (OFString*)description
{
	return [OFString stringWithFormat:
	return [OFString stringWithFormat: @"A PostgreSQL command failed: %@\n"
	    @"A PostgreSQL command in class %@ failed: %s\nCommand: %@",
	    [self inClass], PQerrorMessage([_connection PG_connection]),
	    _command];
					   @"Command: %@", _error, _command];
}

- (OFString*)command
{
	OF_GETTER(_command, NO)
}
@end

Modified exceptions/PGConnectionFailedException.m from [de24e68bdc] to [b1115b7f5a]. 

1
2
3
4
5
6
7

8
9
10

11
12

1
2
3
4
5
6

7



8
9
10







-
+
-
-
-
+



#import "PGConnectionFailedException.h"

@implementation PGConnectionFailedException
- (OFString*)description
{
	return [OFString stringWithFormat:
	    @"Establishing a PostgreSQL connection in class %@ failed:\n%s\n"
	    @"Establishing a PostgreSQL connection failed:\n%@\n"
	    "Parameters: %@", [self inClass],
	    PQerrorMessage([_connection PG_connection]),
	    [_connection parameters]];
	    "Parameters: %@", _error, [_connection parameters]];
}
@end

Modified exceptions/PGException.h from [c9366d7488] to [9572250036]. 

1
2
3
4
5
6
7

8
9
10
11
12
13
14
15

16
17

18
19

1
2
3
4
5
6
7
8
9
10
11
12
13
14


15


16
17
18








+






-
-
+
-
-
+



#import <ObjFW/ObjFW.h>

#import "PGConnection.h"

@interface PGException: OFException
{
	PGConnection *_connection;
	OFString *_error;
}

#ifdef OF_HAVE_PROPERTIES
@property (readonly, retain, nonatomic) PGConnection *connection;
#endif

+ exceptionWithClass: (Class)class_
	  connection: (PGConnection*)connection;
+ (instancetype)exceptionWithConnection: (PGConnection*)connection;
- initWithClass: (Class)class_
     connection: (PGConnection*)connection;
- initWithConnection: (PGConnection*)connection;
- (PGConnection*)connection;
@end

Modified exceptions/PGException.m from [603d30aa28] to [63db1fe590]. 

1
2
3
4
5

6
7

8
9
10
11
12

13
14

15

16








17
18
19
20
21
22
23

24
25
26
27
28
29
30

31
32

33
34
35
36
37
38
39

1
2
3


4
5

6

7
8


9
10

11
12
13

14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

36


37
38
39
40
41
42
43
44




-
-
+

-
+
-


-
-
+

-
+

+
-
+
+
+
+
+
+
+
+







+






-
+
-
-
+








#import "PGException.h"

@implementation PGException
+ exceptionWithClass: (Class)class
	  connection: (PGConnection*)connection
+ (instancetype)exceptionWithConnection: (PGConnection*)connection
{
	return [[[self alloc] initWithClass: class
	return [[[self alloc] initWithConnection: connection] autorelease];
				 connection: connection] autorelease];
}

- initWithClass: (Class)class
     connection: (PGConnection*)connection
- initWithConnection: (PGConnection*)connection
{
	self = [super initWithClass: class];
	self = [super init];

	@try {
	_connection = [connection retain];
		_connection = [connection retain];
		_error = [[OFString alloc]
		    initWithCString: PQerrorMessage([_connection PG_connection])
			   encoding: OF_STRING_ENCODING_NATIVE];
	} @catch (id e) {
		[self release];
		@throw e;
	}

	return self;
}

- (void)dealloc
{
	[_connection release];
	[_error release];

	[super dealloc];
}

- (OFString*)description
{
	return [OFString stringWithFormat:
	return [OFString stringWithFormat: @"A PostgreSQL operation failed: %@",
	    @"A PostgreSQL operation in class %@ failed: %s", [self inClass],
	    PQerrorMessage([_connection PG_connection])];
					   _error];
}

- (PGConnection*)connection
{
	OF_GETTER(_connection, NO)
}
@end

Fossil 2.23 [47362306a7] 2023-11-01 18:56:47
This page was generated in about 0.018s