This file is indexed.

/usr/lib/python3/dist-packages/postgresql/test/test_dbapi20.py is in python3-postgresql 1.1.0-1build1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  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
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 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
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
##
# .test.test_dbapi20 - test .driver.dbapi20
##
import unittest
import time
from ..temporal import pg_tmp

##
# Various Adjustments for .driver.dbapi20
#
# Log: dbapi20.py
# Revision 1.10  2003/10/09 03:14:14  zenzen
# Add test for DB API 2.0 optional extension, where database exceptions
# are exposed as attributes on the Connection object.
#
# Revision 1.9  2003/08/13 01:16:36  zenzen
# Minor tweak from Stefan Fleiter
#
# Revision 1.8  2003/04/10 00:13:25  zenzen
# Changes, as per suggestions by M.-A. Lemburg
# - Add a table prefix, to ensure namespace collisions can always be avoided
#
# Revision 1.7  2003/02/26 23:33:37  zenzen
# Break out DDL into helper functions, as per request by David Rushby
#
# Revision 1.6  2003/02/21 03:04:33  zenzen
# Stuff from Henrik Ekelund:
#     added test_None
#     added test_nextset & hooks
#
# Revision 1.5  2003/02/17 22:08:43  zenzen
# Implement suggestions and code from Henrik Eklund - test that cursor.arraysize
# defaults to 1 & generic cursor.callproc test added
#
# Revision 1.4  2003/02/15 00:16:33  zenzen
# Changes, as per suggestions and bug reports by M.-A. Lemburg,
# Matthew T. Kromer, Federico Di Gregorio and Daniel Dittmar
# - Class renamed
# - Now a subclass of TestCase, to avoid requiring the driver stub
#   to use multiple inheritance
# - Reversed the polarity of buggy test in test_description
# - Test exception heirarchy correctly
# - self.populate is now self._populate(), so if a driver stub
#   overrides self.ddl1 this change propogates
# - VARCHAR columns now have a width, which will hopefully make the
#   DDL even more portible (this will be reversed if it causes more problems)
# - cursor.rowcount being checked after various execute and fetchXXX methods
# - Check for fetchall and fetchmany returning empty lists after results
#   are exhausted (already checking for empty lists if select retrieved
#   nothing
# - Fix bugs in test_setoutputsize_basic and test_setinputsizes
#
class test_dbapi20(unittest.TestCase):
	"""
	Test a database self.driver for DB API 2.0 compatibility.
	This implementation tests Gadfly, but the TestCase
	is structured so that other self.drivers can subclass this 
	test case to ensure compiliance with the DB-API. It is 
	expected that this TestCase may be expanded in the future
	if ambiguities or edge conditions are discovered.

	The 'Optional Extensions' are not yet being tested.

	self.drivers should subclass this test, overriding setUp, tearDown,
	self.driver, connect_args and connect_kw_args. Class specification
	should be as follows:

	import dbapi20 
	class mytest(dbapi20.DatabaseAPI20Test):
		[...] 

	__rcs_id__  = 'Id: dbapi20.py,v 1.10 2003/10/09 03:14:14 zenzen Exp'
	__version__ = 'Revision: 1.10'
	__author__ = 'Stuart Bishop <zen@shangri-la.dropbear.id.au>'
	"""

	import postgresql.driver.dbapi20 as driver
	table_prefix = 'dbapi20test_' # If you need to specify a prefix for tables

	booze_name = table_prefix + 'booze'
	ddl1 = 'create temp table %s (name varchar(20))' % booze_name
	ddl2 = 'create temp table %sbarflys (name varchar(20))' % table_prefix
	xddl1 = 'drop table %sbooze' % table_prefix
	xddl2 = 'drop table %sbarflys' % table_prefix

	lowerfunc = 'lower' # Name of stored procedure to convert string->lowercase

	# Some drivers may need to override these helpers, for example adding
	# a 'commit' after the execute.
	def executeDDL1(self,cursor):
		cursor.execute(self.ddl1)

	def executeDDL2(self,cursor):
		cursor.execute(self.ddl2)

	def tearDown(self):
		con = self._connect()
		try:
			cur = con.cursor()
			for ddl in (self.xddl1, self.xddl2):
				try: 
					cur.execute(ddl)
					con.commit()
				except self.driver.Error: 
					# Assume table didn't exist. Other tests will check if
					# execute is busted.
					pass
		finally:
			con.close()

	def _connect(self):
		pg_tmp.init()
		host, port = pg_tmp.cluster.address()
		return self.driver.connect(
			user = 'test', host = host, port = port,
		)

	def test_connect(self):
		con = self._connect()
		con.close()

	def test_apilevel(self):
		try:
			# Must exist
			apilevel = self.driver.apilevel
			# Must equal 2.0
			self.assertEqual(apilevel,'2.0')
		except AttributeError:
			self.fail("Driver doesn't define apilevel")

	def test_threadsafety(self):
		try:
			# Must exist
			threadsafety = self.driver.threadsafety
			# Must be a valid value
			self.assertTrue(threadsafety in (0,1,2,3))
		except AttributeError:
			self.fail("Driver doesn't define threadsafety")

	def test_paramstyle(self):
		try:
			# Must exist
			paramstyle = self.driver.paramstyle
			# Must be a valid value
			self.assertTrue(paramstyle in (
				'qmark','numeric','named','format','pyformat'
				))
		except AttributeError:
			self.fail("Driver doesn't define paramstyle")

	def test_Exceptions(self):
		# Make sure required exceptions exist, and are in the
		# defined heirarchy.
		self.assertTrue(issubclass(self.driver.InterfaceError,self.driver.Error))
		self.assertTrue(issubclass(self.driver.DatabaseError,self.driver.Error))
		self.assertTrue(issubclass(self.driver.OperationalError,self.driver.Error))
		self.assertTrue(issubclass(self.driver.IntegrityError,self.driver.Error))
		self.assertTrue(issubclass(self.driver.InternalError,self.driver.Error))
		self.assertTrue(issubclass(self.driver.ProgrammingError,self.driver.Error))
		self.assertTrue(issubclass(self.driver.NotSupportedError,self.driver.Error))

	def test_ExceptionsAsConnectionAttributes(self):
		# OPTIONAL EXTENSION
		# Test for the optional DB API 2.0 extension, where the exceptions
		# are exposed as attributes on the Connection object
		# I figure this optional extension will be implemented by any
		# driver author who is using this test suite, so it is enabled
		# by default.
		con = self._connect()
		try:
			drv = self.driver
			self.assertTrue(con.Warning is drv.Warning)
			self.assertTrue(con.Error is drv.Error)
			self.assertTrue(con.InterfaceError is drv.InterfaceError)
			self.assertTrue(con.DatabaseError is drv.DatabaseError)
			self.assertTrue(con.OperationalError is drv.OperationalError)
			self.assertTrue(con.IntegrityError is drv.IntegrityError)
			self.assertTrue(con.InternalError is drv.InternalError)
			self.assertTrue(con.ProgrammingError is drv.ProgrammingError)
			self.assertTrue(con.NotSupportedError is drv.NotSupportedError)
		finally:
			con.close()

	def test_commit(self):
		con = self._connect()
		try:
			# Commit must work, even if it doesn't do anything
			con.commit()
		finally:
			con.close()

	def test_rollback(self):
		con = self._connect()
		# If rollback is defined, it should either work or throw
		# the documented exception
		try:
			if hasattr(con,'rollback'):
				try:
					con.rollback()
				except self.driver.NotSupportedError:
					pass
		finally:
			con.close()

	def test_cursor(self):
		con = self._connect()
		try:
			cur = con.cursor()
		finally:
			con.close()

	def test_cursor_isolation(self):
		con = self._connect()
		try:
			# Make sure cursors created from the same connection have
			# the documented transaction isolation level
			cur1 = con.cursor()
			cur2 = con.cursor()
			self.executeDDL1(cur1)
			cur1.execute("insert into %sbooze values ('Victoria Bitter')" % (
				self.table_prefix
				))
			cur2.execute("select name from %sbooze" % self.table_prefix)
			booze = cur2.fetchall()
			self.assertEqual(len(booze),1)
			self.assertEqual(len(booze[0]),1)
			self.assertEqual(booze[0][0],'Victoria Bitter')
		finally:
			con.close()

	def test_description(self):
		con = self._connect()
		try:
			cur = con.cursor()
			self.executeDDL1(cur)
			self.assertEqual(cur.description,None,
				'cursor.description should be none after executing a '
				'statement that can return no rows (such as DDL)'
			)
			cur.execute('select name from %sbooze' % self.table_prefix)
			self.assertEqual(len(cur.description),1,
				'cursor.description describes too many columns'
			)
			self.assertEqual(len(cur.description[0]),7,
				'cursor.description[x] tuples must have 7 elements'
			)
			self.assertEqual(cur.description[0][0].lower(),'name',
				'cursor.description[x][0] must return column name'
			)
			self.assertEqual(cur.description[0][1],self.driver.STRING,
				'cursor.description[x][1] must return column type. Got %r'
					% cur.description[0][1]
			)

			# Make sure self.description gets reset
			self.executeDDL2(cur)
			self.assertEqual(cur.description,None,
				'cursor.description not being set to None when executing '
				'no-result statements (eg. DDL)'
			)
		finally:
			con.close()

	def test_rowcount(self):
		con = self._connect()
		try:
			cur = con.cursor()
			self.executeDDL1(cur)
			self.assertEqual(cur.rowcount, -1,
				'cursor.rowcount should be -1 after executing no-result '
				'statements'
			)
			cur.execute("insert into %sbooze values ('Victoria Bitter')" % (
				self.table_prefix
			))
			self.assertEqual(cur.rowcount, 1,
				'cursor.rowcount should == number or rows inserted, or '
				'set to -1 after executing an insert statement'
			)
			cur.execute("insert into %sbooze select 'Victoria Bitter' WHERE FALSE" % (
				self.table_prefix
			))
			self.assertEqual(cur.rowcount, 0)
			cur.execute("insert into %sbooze select 'First' UNION ALL select 'second'" % (
				self.table_prefix
			))
			self.assertEqual(cur.rowcount, 2)

			cur.execute("select name from %sbooze" % self.table_prefix)
			self.assertEqual(cur.rowcount, -1,
				'cursor.rowcount should == number of rows returned, or '
				'set to -1 after executing a select statement'
			)
			self.executeDDL2(cur)
			self.assertEqual(cur.rowcount, -1,
				'cursor.rowcount not being reset to -1 after executing '
				'no-result statements'
			)
		finally:
			con.close()

	lower_func = 'lower'
	def test_callproc(self):
		con = self._connect()
		try:
			cur = con.cursor()
			if self.lower_func and hasattr(cur,'callproc'):
				r = cur.callproc(self.lower_func,('FOO',))
				self.assertEqual(len(r),1)
				self.assertEqual(r[0],'FOO')
				r = cur.fetchall()
				self.assertEqual(len(r),1,'callproc produced no result set')
				self.assertEqual(len(r[0]),1,
					'callproc produced invalid result set'
				)
				self.assertEqual(r[0][0],'foo',
					'callproc produced invalid results'
				)
		finally:
			con.close()

	def test_close(self):
		con = self._connect()
		try:
			cur = con.cursor()
		finally:
			con.close()

		# cursor.execute should raise an Error if called after connection
		# closed
		self.assertRaises(self.driver.Error,self.executeDDL1,cur)

		# connection.commit should raise an Error if called after connection'
		# closed.'
		self.assertRaises(self.driver.Error,con.commit)

		# connection.close should raise an Error if called more than once
		self.assertRaises(self.driver.Error,con.close)

	def test_cursor_close(self):
		con = self._connect()
		try:
			cur = con.cursor()
			cur.close()
			# cursor.execute should raise an Error if called after cursor.close
			# closed
			self.assertRaises(self.driver.Error,self.executeDDL1,cur)
			# cursor.executemany should raise an Error if called after connection'
			# closed.'
			self.assertRaises(self.driver.Error,cur.executemany,'foo', [])

			self.assertRaises(self.driver.Error,cur.callproc,'generate_series', [1, 10])

			# cursor.close should raise an Error if called more than once
			self.assertRaises(self.driver.Error,cur.close)
		finally:
			con.close()

	def test_execute(self):
		con = self._connect()
		try:
			cur = con.cursor()
			self._paraminsert(cur)
		finally:
			con.close()

	def test_format_execute(self):
		self.driver.paramstyle = 'format'
		try:
			self.test_execute()
		finally:
			self.driver.paramstyle = 'pyformat'

	def _paraminsert(self,cur):
		self.executeDDL1(cur)
		cur.execute("insert into %sbooze values ('Victoria Bitter')" % (
			self.table_prefix
		))
		self.assertTrue(cur.rowcount in (-1,1))

		if self.driver.paramstyle == 'qmark':
			cur.execute(
				'insert into %sbooze values (?)' % self.table_prefix,
				("Cooper's",)
			)
		elif self.driver.paramstyle == 'numeric':
			cur.execute(
				'insert into %sbooze values (:1)' % self.table_prefix,
				("Cooper's",)
			)
		elif self.driver.paramstyle == 'named':
			cur.execute(
				'insert into %sbooze values (:beer)' % self.table_prefix, 
				{'beer':"Cooper's"}
			)
		elif self.driver.paramstyle == 'format':
			cur.execute(
				'insert into %sbooze values (%%s)' % self.table_prefix,
				("Cooper's",)
			)
		elif self.driver.paramstyle == 'pyformat':
			cur.execute(
				'insert into %sbooze values (%%(beer)s)' % self.table_prefix,
				{'beer':"Cooper's"}
			)
		else:
			self.fail('Invalid paramstyle')
		self.assertTrue(cur.rowcount in (-1,1))

		cur.execute('select name from %sbooze' % self.table_prefix)
		res = cur.fetchall()
		self.assertEqual(len(res),2,'cursor.fetchall returned too few rows')
		beers = [res[0][0],res[1][0]]
		beers.sort()
		self.assertEqual(beers[0],"Cooper's",
			'cursor.fetchall retrieved incorrect data, or data inserted '
			'incorrectly'
		)
		self.assertEqual(beers[1],"Victoria Bitter",
			'cursor.fetchall retrieved incorrect data, or data inserted '
			'incorrectly'
		)

	def test_executemany(self):
		con = self._connect()
		try:
			cur = con.cursor()
			self.executeDDL1(cur)
			largs = [ ("Cooper's",) , ("Boag's",) ]
			margs = [ {'beer': "Cooper's"}, {'beer': "Boag's"} ]
			if self.driver.paramstyle == 'qmark':
				cur.executemany(
					'insert into %sbooze values (?)' % self.table_prefix,
					largs
				)
			elif self.driver.paramstyle == 'numeric':
				cur.executemany(
					'insert into %sbooze values (:1)' % self.table_prefix,
					largs
				)
			elif self.driver.paramstyle == 'named':
				cur.executemany(
					'insert into %sbooze values (:beer)' % self.table_prefix,
					margs
				)
			elif self.driver.paramstyle == 'format':
				cur.executemany(
					'insert into %sbooze values (%%s)' % self.table_prefix,
					largs
				)
			elif self.driver.paramstyle == 'pyformat':
				cur.executemany(
					'insert into %sbooze values (%%(beer)s)' % (
						self.table_prefix
					),
					margs
				)
			else:
				self.fail('Unknown paramstyle')
			self.assertTrue(cur.rowcount in (-1,2),
				'insert using cursor.executemany set cursor.rowcount to '
				'incorrect value %r' % cur.rowcount
			)
			cur.execute('select name from %sbooze' % self.table_prefix)
			res = cur.fetchall()
			self.assertEqual(len(res),2,
				'cursor.fetchall retrieved incorrect number of rows'
			)
			beers = [res[0][0],res[1][0]]
			beers.sort()
			self.assertEqual(beers[0],"Boag's",'incorrect data retrieved')
			self.assertEqual(beers[1],"Cooper's",'incorrect data retrieved')
		finally:
			con.close()

	def test_format_executemany(self):
		self.driver.paramstyle = 'format'
		try:
			self.test_executemany()
		finally:
			self.driver.paramstyle = 'pyformat'

	def test_fetchone(self):
		con = self._connect()
		try:
			cur = con.cursor()

			# cursor.fetchone should raise an Error if called before
			# executing a select-type query
			self.assertRaises(self.driver.Error,cur.fetchone)

			# cursor.fetchone should raise an Error if called after
			# executing a query that cannnot return rows
			self.executeDDL1(cur)
			self.assertRaises(self.driver.Error,cur.fetchone)

			cur.execute('select name from %sbooze' % self.table_prefix)
			self.assertEqual(cur.fetchone(),None,
				'cursor.fetchone should return None if a query retrieves '
				'no rows'
			)
			self.assertTrue(cur.rowcount in (-1,0))

			# cursor.fetchone should raise an Error if called after
			# executing a query that cannnot return rows
			cur.execute("insert into %sbooze values ('Victoria Bitter')" % (
				self.table_prefix
			))
			self.assertRaises(self.driver.Error,cur.fetchone)

			cur.execute('select name from %sbooze' % self.table_prefix)
			r = cur.fetchone()
			self.assertEqual(len(r),1,
				'cursor.fetchone should have retrieved a single row'
			)
			self.assertEqual(r[0],'Victoria Bitter',
				'cursor.fetchone retrieved incorrect data'
			)
			self.assertEqual(cur.fetchone(),None,
				'cursor.fetchone should return None if no more rows available'
			)
			self.assertTrue(cur.rowcount in (-1,1))
		finally:
			con.close()

	samples = [
		'Carlton Cold',
		'Carlton Draft',
		'Mountain Goat',
		'Redback',
		'Victoria Bitter',
		'XXXX'
	]

	def _populate(self):
		'''
		Return a list of sql commands to setup the DB for the fetch tests.
		'''
		populate = [
			"insert into %sbooze values ('%s')" % (self.table_prefix,s) 
				for s in self.samples
		]
		return populate

	def test_fetchmany(self):
		con = self._connect()
		try:
			cur = con.cursor()

			# cursor.fetchmany should raise an Error if called without
			#issuing a query
			self.assertRaises(self.driver.Error,cur.fetchmany,4)

			self.executeDDL1(cur)
			for sql in self._populate():
				cur.execute(sql)

			cur.execute('select name from %sbooze' % self.table_prefix)
			r = cur.fetchmany()
			self.assertEqual(len(r),1,
				'cursor.fetchmany retrieved incorrect number of rows, '
				'default of arraysize is one.'
			)
			cur.arraysize=10
			r = cur.fetchmany(3) # Should get 3 rows
			self.assertEqual(len(r),3,
				'cursor.fetchmany retrieved incorrect number of rows'
			)
			r = cur.fetchmany(4) # Should get 2 more
			self.assertEqual(len(r),2,
				'cursor.fetchmany retrieved incorrect number of rows'
			)
			r = cur.fetchmany(4) # Should be an empty sequence
			self.assertEqual(len(r),0,
				'cursor.fetchmany should return an empty sequence after '
				'results are exhausted'
			)
			self.assertTrue(cur.rowcount in (-1,6))

			# Same as above, using cursor.arraysize
			cur.arraysize=4
			cur.execute('select name from %sbooze' % self.table_prefix)
			r = cur.fetchmany() # Should get 4 rows
			self.assertEqual(len(r),4,
				'cursor.arraysize not being honoured by fetchmany'
			)
			r = cur.fetchmany() # Should get 2 more
			self.assertEqual(len(r),2)
			r = cur.fetchmany() # Should be an empty sequence
			self.assertEqual(len(r),0)
			self.assertTrue(cur.rowcount in (-1,6))

			cur.arraysize=6
			cur.execute('select name from %sbooze' % self.table_prefix)
			rows = cur.fetchmany() # Should get all rows
			self.assertTrue(cur.rowcount in (-1,6))
			self.assertEqual(len(rows),6)
			self.assertEqual(len(rows),6)
			rows = [r[0] for r in rows]
			rows.sort()

			# Make sure we get the right data back out
			for i in range(0,6):
				self.assertEqual(rows[i],self.samples[i],
					'incorrect data retrieved by cursor.fetchmany'
				)

			rows = cur.fetchmany() # Should return an empty list
			self.assertEqual(len(rows),0,
				'cursor.fetchmany should return an empty sequence if '
				'called after the whole result set has been fetched'
			)
			self.assertTrue(cur.rowcount in (-1,6))

			self.executeDDL2(cur)
			cur.execute('select name from %sbarflys' % self.table_prefix)
			r = cur.fetchmany() # Should get empty sequence
			self.assertEqual(len(r),0,
				'cursor.fetchmany should return an empty sequence if '
				'query retrieved no rows'
			)
			self.assertTrue(cur.rowcount in (-1,0))

		finally:
			con.close()

	def test_fetchall(self):
		con = self._connect()
		try:
			cur = con.cursor()
			# cursor.fetchall should raise an Error if called
			# without executing a query that may return rows (such
			# as a select)
			self.assertRaises(self.driver.Error, cur.fetchall)

			self.executeDDL1(cur)
			for sql in self._populate():
				cur.execute(sql)

			# cursor.fetchall should raise an Error if called
			# after executing a a statement that cannot return rows
			self.assertRaises(self.driver.Error,cur.fetchall)

			cur.execute('select name from %sbooze' % self.table_prefix)
			rows = cur.fetchall()
			self.assertTrue(cur.rowcount in (-1,len(self.samples)))
			self.assertEqual(len(rows),len(self.samples),
				'cursor.fetchall did not retrieve all rows'
			)
			rows = [r[0] for r in rows]
			rows.sort()
			for i in range(0,len(self.samples)):
				self.assertEqual(rows[i],self.samples[i],
				'cursor.fetchall retrieved incorrect rows'
			)
			rows = cur.fetchall()
			self.assertEqual(
				len(rows),0,
				'cursor.fetchall should return an empty list if called '
				'after the whole result set has been fetched'
			)
			self.assertTrue(cur.rowcount in (-1,len(self.samples)))

			self.executeDDL2(cur)
			cur.execute('select name from %sbarflys' % self.table_prefix)
			rows = cur.fetchall()
			self.assertTrue(cur.rowcount in (-1,0))
			self.assertEqual(len(rows),0,
				'cursor.fetchall should return an empty list if '
				'a select query returns no rows'
			)
		finally:
			con.close()

	def test_mixedfetch(self):
		con = self._connect()
		try:
			cur = con.cursor()
			self.executeDDL1(cur)
			for sql in self._populate():
				cur.execute(sql)

			cur.execute('select name from %sbooze' % self.table_prefix)
			rows1  = cur.fetchone()
			rows23 = cur.fetchmany(2)
			rows4  = cur.fetchone()
			rows56 = cur.fetchall()
			self.assertTrue(cur.rowcount in (-1,6))
			self.assertEqual(len(rows23),2,
				'fetchmany returned incorrect number of rows'
			)
			self.assertEqual(len(rows56),2,
				'fetchall returned incorrect number of rows'
			)

			rows = [rows1[0]]
			rows.extend([rows23[0][0],rows23[1][0]])
			rows.append(rows4[0])
			rows.extend([rows56[0][0],rows56[1][0]])
			rows.sort()
			for i in range(0,len(self.samples)):
				self.assertEqual(rows[i],self.samples[i],
					'incorrect data retrieved or inserted'
				)
		finally:
			con.close()

	def help_nextset_setUp(self,cur):
		'''
		Should create a procedure called deleteme
		that returns two result sets, first the 
		number of rows in booze then "name from booze"
		'''
		cur.execute('select name from ' + self.booze_name)
		cur.execute('select count(*) from ' + self.booze_name)

	def help_nextset_tearDown(self,cur):
		'If cleaning up is needed after nextSetTest'
		pass

	def test_nextset(self):
		con = self._connect()
		try:
			cur = con.cursor()
			if not hasattr(cur,'nextset'):
				return

			try:
				self.executeDDL1(cur)
				sql=self._populate()
				for sql in self._populate():
					cur.execute(sql)

				self.help_nextset_setUp(cur)

				numberofrows=cur.fetchone()
				assert numberofrows[0]== len(self.samples)
				assert cur.nextset()
				names=cur.fetchall()
				assert len(names) == len(self.samples)
				s=cur.nextset()
				assert s == None,'No more return sets, should return None'
			finally:
				self.help_nextset_tearDown(cur)
		finally:
			con.close()

	def test_arraysize(self):
		# Not much here - rest of the tests for this are in test_fetchmany
		con = self._connect()
		try:
			cur = con.cursor()
			self.assertTrue(hasattr(cur,'arraysize'),
				'cursor.arraysize must be defined'
				)
		finally:
			con.close()

	def test_setinputsizes(self):
		con = self._connect()
		try:
			cur = con.cursor()
			cur.setinputsizes( (25,) )
			self._paraminsert(cur) # Make sure cursor still works
		finally:
			con.close()

	def test_setoutputsize_basic(self):
		# Basic test is to make sure setoutputsize doesn't blow up
		con = self._connect()
		try:
			cur = con.cursor()
			cur.setoutputsize(1000)
			cur.setoutputsize(2000,0)
			self._paraminsert(cur) # Make sure the cursor still works
		finally:
			con.close()

	def test_setoutputsize(self):
		# Real test for setoutputsize is driver dependant
		pass

	def test_autocommit(self):
		con = self._connect()
		con2 = self._connect()
		try:
			con.autocommit = True
			# autocommit mode on, commit/abort on inappropriate.
			self.assertRaises(
				con.InterfaceError,
				con.commit
			)
			self.assertRaises(
				con.InterfaceError,
				con.rollback
			)
			c = con.cursor()
			c.execute("create table some_committed_table(i int)")
			# if this fails, autocommit had no effect on `con`
			con2.cursor().execute("drop table some_committed_table")
			con2.commit()
		finally:
			con.close()
			con2.close()

	def test_None(self):
		con = self._connect()
		try:
			cur = con.cursor()
			self.executeDDL1(cur)
			cur.execute('insert into %sbooze values (NULL)' % self.table_prefix)
			cur.execute('select name from %sbooze' % self.table_prefix)
			r = cur.fetchall()
			self.assertEqual(len(r),1)
			self.assertEqual(len(r[0]),1)
			self.assertEqual(r[0][0],None,'NULL value not returned as None')
		finally:
			con.close()

	def test_Date(self):
		d1 = self.driver.Date(2002,12,25)
		d2 = self.driver.DateFromTicks(time.mktime((2002,12,25,0,0,0,0,0,0)))
		# Can we assume this? API doesn't specify, but it seems implied
		self.assertEqual(str(d1),str(d2))

	def test_Time(self):
		t1 = self.driver.Time(13,45,30)
		t2 = self.driver.TimeFromTicks(time.mktime((2001,1,1,13,45,30,0,0,0)))
		# Can we assume this? API doesn't specify, but it seems implied
		self.assertEqual(str(t1),str(t2))

	def test_Timestamp(self):
		t1 = self.driver.Timestamp(2002,12,25,13,45,30)
		t2 = self.driver.TimestampFromTicks(
			time.mktime((2002,12,25,13,45,30,0,0,0))
		)
		# Can we assume this? API doesn't specify, but it seems implied
		#self.assertEqual(str(t1),str(t2))

	def test_Binary(self):
		b = self.driver.Binary(b'Something')
		b = self.driver.Binary(b'')

	def test_STRING(self):
		self.assertTrue(hasattr(self.driver,'STRING'),
			'module.STRING must be defined'
		)

	def test_BINARY(self):
		self.assertTrue(hasattr(self.driver,'BINARY'),
			'module.BINARY must be defined.'
		)

	def test_NUMBER(self):
		self.assertTrue(hasattr(self.driver,'NUMBER'),
			'module.NUMBER must be defined.'
		)

	def test_DATETIME(self):
		self.assertTrue(hasattr(self.driver,'DATETIME'),
			'module.DATETIME must be defined.'
		)

	def test_ROWID(self):
		self.assertTrue(hasattr(self.driver,'ROWID'),
			'module.ROWID must be defined.'
		)

	def test_placeholder_escape(self):
		con = self._connect()
		try:
			c = con.cursor()
			c.execute("SELECT 100 %% %s", (99,))
			self.assertEqual(1, c.fetchone()[0])
			c.execute("SELECT 100 %% %(foo)s", {'foo': 99})
			self.assertEqual(1, c.fetchone()[0])
		finally:
			con.close()

if __name__ == '__main__':
	unittest.main()