def test_connect(self):
c = ocpgdb.connect(**scratch_db)
self.failUnless(c.fileno() >= 0)
self.failUnless(isinstance(c.conninfo, str))
self.assertEqual(c.notices, [])
self.failUnless(isinstance(c.host, str))
self.failUnless(isinstance(c.port, int))
self.failUnless(isinstance(c.db, str))
self.failUnless(isinstance(c.user, str))
self.failUnless(isinstance(c.password, str))
self.failUnless(isinstance(c.options, str))
self.failUnless(isinstance(c.protocolVersion, int))
self.failUnless(c.protocolVersion >= 2)
self.failUnless(isinstance(c.serverVersion, int))
self.failUnless(c.serverVersion >= 70000)
self.failUnless(not c.closed)
c.close()
self.failUnless(c.closed)
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'host')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'port')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'db')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'user')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'password')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'options')
self.assertRaises(ocpgdb.ProgrammingError, c.fileno)
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'protocolVersion')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'serverVersion')
c.close()
def test_py_dateime(self):
import datetime
db = ocpgdb.connect(**scratch_db)
db.use_python_datetime()
try:
self._test(db, None, 'timestamp')
self._test(db, datetime.datetime(2007, 5, 8, 15, 9, 32, 23),
'timestamp')
self._test(db, datetime.datetime(1900, 5, 8, 15, 9, 32, 23),
'timestamp')
self._test(db, datetime.datetime(2200, 5, 8, 15, 9, 32, 23),
'timestamp')
self._test(db, None, 'time')
self._test(db, datetime.time(15, 9, 32, 23), 'time')
self._test(db, datetime.time(0, 0, 0, 0), 'time')
self._test(db, datetime.time(23, 59, 59, 999), 'time')
self._test(db, None, 'date')
self._test(db, datetime.date(2007, 5, 8), 'date')
self._test(db, datetime.date(1900, 5, 8), 'date')
self._test(db, datetime.date(2200, 5, 8), 'date')
self._test(db, None, 'interval')
self._test(db, datetime.timedelta(0, 0, 0, 0, 0), 'interval')
self._test(db, datetime.timedelta(0, 0, 0, 0, 0), 'interval')
self._test(db, datetime.timedelta(0, 59, 0, 0, 59, 23), 'interval')
self._test(db, datetime.timedelta(seconds=-1), 'interval')
self._test(db, datetime.timedelta(days=-1), 'interval')
self._test(db, datetime.timedelta(days=-1, seconds=1), 'interval')
self._test(db, datetime.timedelta(days=-1, seconds=-1), 'interval')
finally:
db.close()
def test_connect(self):
c = ocpgdb.connect(**scratch_db)
self.failUnless(c.fileno() >= 0)
self.failUnless(isinstance(c.conninfo, str))
self.assertEqual(c.notices, [])
self.failUnless(isinstance(c.host, str))
self.failUnless(isinstance(c.port, int))
self.failUnless(isinstance(c.db, str))
self.failUnless(isinstance(c.user, str))
self.failUnless(isinstance(c.password, str))
self.failUnless(isinstance(c.options, str))
self.failUnless(isinstance(c.protocolVersion, int))
self.failUnless(c.protocolVersion >= 2)
self.failUnless(isinstance(c.serverVersion, int))
self.failUnless(c.serverVersion >= 70000)
self.failUnless(not c.closed)
self.assertEqual(c.transactionStatus, ocpgdb.TRANS_IDLE)
old_verb = c.setErrorVerbosity(ocpgdb.ERRORS_VERBOSE)
self.assertEqual(old_verb, ocpgdb.ERRORS_DEFAULT)
old_verb = c.setErrorVerbosity(ocpgdb.ERRORS_DEFAULT)
self.assertEqual(old_verb, ocpgdb.ERRORS_VERBOSE)
c.close()
self.failUnless(c.closed)
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'host')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'port')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'db')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'user')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'password')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'options')
self.assertRaises(ocpgdb.ProgrammingError, c.fileno)
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'protocolVersion')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'serverVersion')
self.assertRaises(ocpgdb.ProgrammingError, c.close)
def runTest(self):
self.assertHasAttr(ocpgdb, 'Binary')
self.assertHasAttr(ocpgdb, 'Date')
self.assertHasAttr(ocpgdb, 'Time')
self.assertHasAttr(ocpgdb, 'Timestamp')
self.assertHasAttr(ocpgdb, 'DateFromTicks')
self.assertHasAttr(ocpgdb, 'TimestampFromTicks')
self.assertHasAttr(ocpgdb, 'TimeFromTicks')
self.assertHasAttr(ocpgdb, 'STRING')
self.assertHasAttr(ocpgdb, 'BINARY')
self.assertHasAttr(ocpgdb, 'NUMBER')
self.assertHasAttr(ocpgdb, 'DATETIME')
self.assertHasAttr(ocpgdb, 'ROWID')
self.db = ocpgdb.connect(**scratch_db)
self.assertExecute(None, 'select null')
self.assertRoundTrip(ocpgdb.DATETIME, ocpgdb.Date(2010,5,11))
self.assertRoundTrip(ocpgdb.DATETIME, ocpgdb.Time(13,14,15))
self.assertRoundTrip(ocpgdb.DATETIME,
ocpgdb.Timestamp(2010,5,11, 13,14,15))
self.assertRoundTrip(ocpgdb.DATETIME,
ocpgdb.DateFromTicks(1273547655))
self.assertRoundTrip(ocpgdb.DATETIME,
ocpgdb.TimeFromTicks(1273547655))
self.assertRoundTrip(ocpgdb.DATETIME,
ocpgdb.TimestampFromTicks(1273547655))
self.assertRoundTrip(ocpgdb.BINARY, ocpgdb.Binary('abc\0'))
self.assertRoundTrip(ocpgdb.STRING, 'abc')
self.assertRoundTrip(ocpgdb.NUMBER, 1)
self.assertRoundTrip(ocpgdb.NUMBER, 1.1)
def test_connect(self):
c = ocpgdb.connect(**scratch_db)
self.failUnless(c.fileno() >= 0)
self.failUnless(isinstance(c.conninfo, str))
self.assertEqual(c.notices, [])
self.failUnless(isinstance(c.host, str))
self.failUnless(isinstance(c.port, int))
self.failUnless(isinstance(c.db, str))
self.failUnless(isinstance(c.user, str))
self.failUnless(isinstance(c.password, str))
self.failUnless(isinstance(c.options, str))
self.failUnless(isinstance(c.protocolVersion, int))
self.failUnless(c.protocolVersion >= 2)
self.failUnless(isinstance(c.serverVersion, int))
self.failUnless(c.serverVersion >= 70000)
self.failUnless(not c.closed)
c.close()
self.failUnless(c.closed)
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'host')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'port')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'db')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'user')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'password')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'options')
self.assertRaises(ocpgdb.ProgrammingError, c.fileno)
self.assertRaises(ocpgdb.ProgrammingError, getattr, c,
'protocolVersion')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'serverVersion')
c.close()
def test_result(self):
c = ocpgdb.connect(**scratch_db)
# Null command
result = ocpgdb.PgConnection.execute(c, '', ())
self.assertEqual(result.status, ocpgdb.PGRES_EMPTY_QUERY)
# Error command
result = ocpgdb.PgConnection.execute(c, 'nonsense_command', ())
self.assertEqual(result.status, ocpgdb.PGRES_FATAL_ERROR)
self.assertEqual(result.errorMessage,
'ERROR: syntax error at or near "nonsense_command"\n'
'LINE 1: nonsense_command\n'
' ^\n')
self.assertEqual(result.errorField(ocpgdb.DIAG_SEVERITY), 'ERROR')
self.assertEqual(result.errorField(ocpgdb.DIAG_SQLSTATE), '42601')
self.assertEqual(result.errorField(ocpgdb.DIAG_MESSAGE_PRIMARY),
'syntax error at or near "nonsense_command"')
self.assertEqual(result.errorField(ocpgdb.DIAG_MESSAGE_DETAIL), None)
self.assertEqual(result.errorField(ocpgdb.DIAG_MESSAGE_HINT), None)
self.assertEqual(result.errorField(ocpgdb.DIAG_STATEMENT_POSITION), '1')
self.assertEqual(result.errorField(ocpgdb.DIAG_INTERNAL_POSITION), None)
self.assertEqual(result.errorField(ocpgdb.DIAG_INTERNAL_QUERY), None)
self.assertEqual(result.errorField(ocpgdb.DIAG_CONTEXT), None)
# Simple select
result = ocpgdb.PgConnection.execute(c, 'select null', ())
self.assertEqual(result.status, ocpgdb.PGRES_TUPLES_OK)
rows = list(result)
self.assertEqual(len(rows), 1)
row = rows[0]
self.assertEqual(len(row), 1)
cell = row[0]
self.assertEqual(cell.format, 1)
self.assertEqual(cell.modifier, -1)
self.assertEqual(cell.name, '?column?')
self.assertEqual(cell.type, ocpgdb.pgoid.unknown)
self.assertEqual(cell.value, None)
def test_result(self):
c = ocpgdb.connect(**scratch_db)
# Null command
result = ocpgdb.PgConnection.execute(c, '', ())
self.assertEqual(result.status, ocpgdb.PGRES_EMPTY_QUERY)
# Error command
result = ocpgdb.PgConnection.execute(c, 'nonsense_command', ())
self.assertEqual(result.status, ocpgdb.PGRES_FATAL_ERROR)
self.assertEqual(result.errorMessage,
'ERROR: syntax error at or near "nonsense_command"\n'
'LINE 1: nonsense_command\n'
' ^\n')
self.assertEqual(result.errorField(ocpgdb.DIAG_SEVERITY), 'ERROR')
self.assertEqual(result.errorField(ocpgdb.DIAG_SQLSTATE), '42601')
self.assertEqual(result.errorField(ocpgdb.DIAG_MESSAGE_PRIMARY),
'syntax error at or near "nonsense_command"')
self.assertEqual(result.errorField(ocpgdb.DIAG_MESSAGE_DETAIL), None)
self.assertEqual(result.errorField(ocpgdb.DIAG_MESSAGE_HINT), None)
self.assertEqual(result.errorField(ocpgdb.DIAG_STATEMENT_POSITION), '1')
self.assertEqual(result.errorField(ocpgdb.DIAG_INTERNAL_POSITION), None)
self.assertEqual(result.errorField(ocpgdb.DIAG_INTERNAL_QUERY), None)
self.assertEqual(result.errorField(ocpgdb.DIAG_CONTEXT), None)
# Simple select
result = ocpgdb.PgConnection.execute(c, 'select null', ())
self.assertEqual(result.status, ocpgdb.PGRES_TUPLES_OK)
rows = list(result)
self.assertEqual(len(rows), 1)
row = rows[0]
self.assertEqual(len(row), 1)
cell = row[0]
self.assertEqual(cell.format, 1)
self.assertEqual(cell.modifier, -1)
self.assertEqual(cell.name, '?column?')
self.assertEqual(cell.type, ocpgdb.pgoid.unknown)
self.assertEqual(cell.value, None)
def test_connect(self):
c = ocpgdb.connect(**scratch_db)
self.assertTrue(c.fileno() >= 0)
self.assertTrue(isinstance(c.conninfo, str))
self.assertEqual(c.notices, [])
self.assertTrue(isinstance(c.host, str))
self.assertTrue(isinstance(c.port, int))
self.assertTrue(isinstance(c.db, str))
self.assertTrue(isinstance(c.user, str))
self.assertTrue(isinstance(c.password, str))
self.assertTrue(isinstance(c.options, str))
self.assertTrue(isinstance(c.protocolVersion, int))
self.assertTrue(c.protocolVersion >= 2)
self.assertTrue(isinstance(c.serverVersion, int))
self.assertTrue(c.serverVersion >= 70000)
self.assertTrue(not c.closed)
self.assertEqual(c.transactionStatus, ocpgdb.TRANS_IDLE)
old_verb = c.setErrorVerbosity(ocpgdb.ERRORS_VERBOSE)
self.assertEqual(old_verb, ocpgdb.ERRORS_DEFAULT)
old_verb = c.setErrorVerbosity(ocpgdb.ERRORS_DEFAULT)
self.assertEqual(old_verb, ocpgdb.ERRORS_VERBOSE)
c.close()
self.assertTrue(c.closed)
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'host')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'port')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'db')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'user')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'password')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'options')
self.assertRaises(ocpgdb.ProgrammingError, c.fileno)
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'protocolVersion')
self.assertRaises(ocpgdb.ProgrammingError, getattr, c, 'serverVersion')
self.assertRaises(ocpgdb.ProgrammingError, c.close)
def test_py_dateime(self):
import datetime
db = ocpgdb.connect(**scratch_db)
db.use_python_datetime()
try:
self._test(db, None, 'timestamp')
self._test(db, datetime.datetime(2007,5,8,15,9,32,23), 'timestamp')
self._test(db, datetime.datetime(1900,5,8,15,9,32,23), 'timestamp')
self._test(db, datetime.datetime(2200,5,8,15,9,32,23), 'timestamp')
self._test(db, None, 'time')
self._test(db, datetime.time(15,9,32,23), 'time')
self._test(db, datetime.time(0,0,0,0), 'time')
self._test(db, datetime.time(23,59,59,999), 'time')
self._test(db, None, 'date')
self._test(db, datetime.date(2007,5,8), 'date')
self._test(db, datetime.date(1900,5,8), 'date')
self._test(db, datetime.date(2200,5,8), 'date')
self._test(db, None, 'interval')
self._test(db, datetime.timedelta(0,0,0,0,0), 'interval')
self._test(db, datetime.timedelta(0,0,0,0,0), 'interval')
self._test(db, datetime.timedelta(0,59,0,0,59,23), 'interval')
self._test(db, datetime.timedelta(seconds=-1), 'interval')
self._test(db, datetime.timedelta(days=-1), 'interval')
self._test(db, datetime.timedelta(days=-1, seconds=1), 'interval')
self._test(db, datetime.timedelta(days=-1, seconds=-1), 'interval')
finally:
db.close()
def runTest(self):
self.assertHasAttr(ocpgdb, 'Binary')
self.assertHasAttr(ocpgdb, 'Date')
self.assertHasAttr(ocpgdb, 'Time')
self.assertHasAttr(ocpgdb, 'Timestamp')
self.assertHasAttr(ocpgdb, 'DateFromTicks')
self.assertHasAttr(ocpgdb, 'TimestampFromTicks')
self.assertHasAttr(ocpgdb, 'TimeFromTicks')
self.assertHasAttr(ocpgdb, 'STRING')
self.assertHasAttr(ocpgdb, 'BINARY')
self.assertHasAttr(ocpgdb, 'NUMBER')
self.assertHasAttr(ocpgdb, 'DATETIME')
self.assertHasAttr(ocpgdb, 'ROWID')
self.db = ocpgdb.connect(**scratch_db)
self.assertExecute(None, 'select null')
self.assertRoundTrip(ocpgdb.DATETIME, ocpgdb.Date(2010,5,11))
self.assertRoundTrip(ocpgdb.DATETIME, ocpgdb.Time(13,14,15))
self.assertRoundTrip(ocpgdb.DATETIME,
ocpgdb.Timestamp(2010,5,11, 13,14,15))
self.assertRoundTrip(ocpgdb.DATETIME,
ocpgdb.DateFromTicks(1273547655))
self.assertRoundTrip(ocpgdb.DATETIME,
ocpgdb.TimeFromTicks(1273547655))
self.assertRoundTrip(ocpgdb.DATETIME,
ocpgdb.TimestampFromTicks(1273547655))
self.assertRoundTrip(ocpgdb.BINARY, ocpgdb.Binary('abc\0'))
self.assertRoundTrip(ocpgdb.STRING, 'abc')
self.assertRoundTrip(ocpgdb.NUMBER, 1)
self.assertRoundTrip(ocpgdb.NUMBER, 1.1)
def main(dbname):
db = dbapi.connect(database=dbname)
#tally(yield_cases(db))
seen_tags, cases_tags = preproc(yield_cases(db))
tag_ids = make_tags(db, seen_tags)
tag_cases(db, tag_ids, cases_tags)
db.commit()
def test_bool(self):
db = ocpgdb.connect(**scratch_db)
try:
self._test(db, None, 'bool')
self._test(db, True, 'bool')
self._test(db, False, 'bool')
finally:
db.close()
def test_bool(self):
db = ocpgdb.connect(**scratch_db)
try:
self._test(db, None, 'bool')
self._test(db, True, 'bool')
self._test(db, False, 'bool')
finally:
db.close()
def test_bytea(self):
db = ocpgdb.connect(**scratch_db)
try:
self._test(db, None, 'bytea')
self._test(db, '', 'bytea')
data = ocpgdb.bytea(''.join([chr(i) for i in range(256)]))
self._test(db, data, 'bytea')
finally:
db.close()
def test_bytea(self):
db = ocpgdb.connect(**scratch_db)
try:
self._test(db, None, 'bytea')
self._test(db, '', 'bytea')
data = ocpgdb.bytea(''.join([chr(i) for i in range(256)]))
self._test(db, data, 'bytea')
finally:
db.close()
def test_decimal(self):
import decimal
db = ocpgdb.connect(**scratch_db)
try:
self._test(db, None, 'numeric')
self._test(db, decimal.Decimal('0'), 'numeric')
self._test(db, decimal.Decimal('0.0000'), 'numeric')
self._test(db, decimal.Decimal('0.000000000000000000000000000000000001'), 'numeric')
# self._test(db, decimal.Decimal('NaN'), 'numeric')
finally:
db.close()
def test_float(self):
db = ocpgdb.connect(**scratch_db)
try:
self._test(db, None, 'float')
self._test(db, 0.0, 'float')
self._test(db, 1.0, 'float')
self._test(db, 1e240, 'float')
self._test(db, -1e240, 'float')
self._test(db, 1e-240, 'float')
self._test(db, -1e-240, 'float')
finally:
db.close()
def test_float(self):
db = ocpgdb.connect(**scratch_db)
try:
self._test(db, None, 'float')
self._test(db, 0.0, 'float')
self._test(db, 1.0, 'float')
self._test(db, 1e240, 'float')
self._test(db, -1e240, 'float')
self._test(db, 1e-240, 'float')
self._test(db, -1e-240, 'float')
finally:
db.close()
def runTest(self):
db = ocpgdb.connect(**scratch_db)
self.assertHasAttr(db, 'close')
self.assertHasAttr(db, 'commit')
self.assertHasAttr(db, 'rollback')
self.assertHasAttr(db, 'cursor')
# After a close, all methods should raise an Error subclass
db.close()
self.assertRaises(ocpgdb.Error, db.close)
self.assertRaises(ocpgdb.Error, db.rollback)
self.assertRaises(ocpgdb.Error, db.commit)
self.assertRaises(ocpgdb.Error, db.cursor)
def runTest(self):
db = ocpgdb.connect(**scratch_db)
self.assertHasAttr(db, 'close')
self.assertHasAttr(db, 'commit')
self.assertHasAttr(db, 'rollback')
self.assertHasAttr(db, 'cursor')
# After a close, all methods should raise an Error subclass
db.close()
self.assertRaises(ocpgdb.Error, db.close)
self.assertRaises(ocpgdb.Error, db.rollback)
self.assertRaises(ocpgdb.Error, db.commit)
self.assertRaises(ocpgdb.Error, db.cursor)
def main(dbname):
db = ocpgdb.connect(database=dbname, use_mx_datetime=True)
persons = Records()
for row in ContactQuery().query(db):
persons.add(row)
for row in CaseQuery().query(db):
persons.add(row)
writer = csv.writer(sys.stdout)
writer.writerow(Record.cols)
for record in persons.sorted():
writer.writerow(record.values())
def test_decimal(self):
import decimal
db = ocpgdb.connect(**scratch_db)
try:
self._test(db, None, 'numeric')
self._test(db, decimal.Decimal('0'), 'numeric')
self._test(db, decimal.Decimal('0.0000'), 'numeric')
self._test(
db, decimal.Decimal('0.000000000000000000000000000000000001'),
'numeric')
# self._test(db, decimal.Decimal('NaN'), 'numeric')
finally:
db.close()
def test_int(self):
db = ocpgdb.connect(**scratch_db)
try:
self._test(db, None, 'int')
self._test(db, 1, 'int')
self._test(db, sys.maxint, 'int')
self._test(db, -sys.maxint, 'int')
self._test(db, None, 'int2')
self._test(db, 1, 'int2')
self.assertRaises(ocpgdb.OperationalError, self._test,
db, sys.maxint, 'int2')
self.assertRaises(ocpgdb.OperationalError, self._test,
db, -sys.maxint, 'int2')
self._test(db, None, 'int8')
self._test(db, 1, 'int8')
self._test(db, sys.maxint * sys.maxint, 'int8')
self._test(db, -(sys.maxint * sys.maxint), 'int8')
finally:
db.close()
def test_int(self):
db = ocpgdb.connect(**scratch_db)
try:
self._test(db, None, 'int')
self._test(db, 1, 'int')
self._test(db, sys.maxint, 'int')
self._test(db, -sys.maxint, 'int')
self._test(db, None, 'int2')
self._test(db, 1, 'int2')
self.assertRaises(ocpgdb.OperationalError, self._test, db,
sys.maxint, 'int2')
self.assertRaises(ocpgdb.OperationalError, self._test, db,
-sys.maxint, 'int2')
self._test(db, None, 'int8')
self._test(db, 1, 'int8')
self._test(db, sys.maxint * sys.maxint, 'int8')
self._test(db, -(sys.maxint * sys.maxint), 'int8')
finally:
db.close()
def test_str(self):
db = ocpgdb.connect(**scratch_db)
try:
self._test(db, None, 'text')
self._test(db, '', 'text')
self._test(db, '\'\"\x01', 'text')
self._test(db, 'A' * 65536, 'text')
self._test(db, None, 'varchar')
self._test(db, '', 'varchar')
self._test(db, '\'\"\x01', 'varchar')
self._test(db, 'A' * 65536, 'varchar')
self._test(db, None, 'varchar(5)')
self._test(db, '', 'varchar(5)')
self._test(db, '\'\"\x01', 'varchar(5)')
self._test(db, 'A' * 65536, 'varchar(5)', 'A' * 5)
self._test(db, None, 'char(5)')
self._test(db, '', 'char(5)', ' ' * 5)
self._test(db, '\'\"\x01', 'char(5)', '\'\"\x01 ')
self._test(db, 'A' * 65536, 'char(5)', 'A' * 5)
finally:
db.close()
def test_str(self):
db = ocpgdb.connect(**scratch_db)
try:
self._test(db, None, 'text')
self._test(db, '', 'text')
self._test(db, '\'\"\x01', 'text')
self._test(db, 'A' * 65536, 'text')
self._test(db, None, 'varchar')
self._test(db, '', 'varchar')
self._test(db, '\'\"\x01', 'varchar')
self._test(db, 'A' * 65536, 'varchar')
self._test(db, None, 'varchar(5)')
self._test(db, '', 'varchar(5)')
self._test(db, '\'\"\x01', 'varchar(5)')
self._test(db, 'A' * 65536, 'varchar(5)', 'A' * 5)
self._test(db, None, 'char(5)')
self._test(db, '', 'char(5)', ' ' * 5)
self._test(db, '\'\"\x01', 'char(5)', '\'\"\x01 ')
self._test(db, 'A' * 65536, 'char(5)', 'A' * 5)
finally:
db.close()
def runTest(self):
db = ocpgdb.connect(**scratch_db)
curs = db.cursor()
# Make sure all the bits are there
self.assertHasAttr(curs, 'description')
self.assertHasAttr(curs, 'rowcount')
#self.assertHasAttr(curs, 'callproc') # Optional
self.assertHasAttr(curs, 'close')
self.assertHasAttr(curs, 'execute')
self.assertHasAttr(curs, 'executemany')
self.assertHasAttr(curs, 'fetchone')
self.assertHasAttr(curs, 'fetchmany')
self.assertHasAttr(curs, 'fetchall')
#self.assertHasAttr(curs, 'nextset') # Optional
self.assertHasAttr(curs, 'arraysize')
self.assertHasAttr(curs, 'setinputsizes') # Stub
self.assertHasAttr(curs, 'setoutputsize') # Stub
# Now test functionality
self.assertRaises(ocpgdb.Error, curs.fetchone)
self.assertEqual(curs.description, None)
self.assertEqual(curs.rowcount, -1)
# description
curs.execute('select null')
self.assertEqual(curs.description,
[('?column?', ocpgdb.pgoid.unknown, None, None, None, None, None)])
self.assertEqual(curs.rowcount, -1)
# execute
curs.execute('select null')
self.assertEqual(curs.fetchall(), [(None,)])
curs.execute('select null', ())
self.assertEqual(curs.fetchall(), [(None,)])
curs.execute('select null', [])
self.assertEqual(curs.fetchall(), [(None,)])
curs.execute('select null', {})
self.assertEqual(curs.fetchall(), [(None,)])
curs.execute('select null, 1')
self.assertEqual(curs.fetchall(), [(None, 1)])
curs.execute('select %s::int, %s::int', (None, 1))
self.assertEqual(curs.fetchall(), [(None, 1)])
curs.execute('select %(a)s::int, %(b)s::int', dict(a=None, b=1))
self.assertEqual(curs.fetchall(), [(None, 1)])
self.assertRaises(ocpgdb.Error, curs.execute,
'select %s::int, %s::int')
db.rollback()
self.assertRaises(ocpgdb.Error, curs.execute,
'select %s::int, %s::int', None)
db.rollback()
self.assertRaises(TypeError, curs.execute,
'select %s::int, %s::int', None, 1)
db.rollback()
self.assertRaises(ocpgdb.Error, curs.execute,
'select %s::int, %s::int', (None, None, None))
db.rollback()
self.assertRaises(ocpgdb.Error, curs.execute,
'select %s::int, %s::int', dict(a=None, b=1))
db.rollback()
self.assertRaises(ocpgdb.Error, curs.execute,
'select %(a)s::int, %(b)s::int', (None, 1))
db.rollback()
curs.execute('create table x ( y text )')
self.assertEqual(curs.rowcount, None)
self.assertRaises(ocpgdb.Error, curs.fetchall)
db.rollback()
# executemany
pass
# fetchone
curs.execute('select null')
self.assertEqual(curs.fetchone(), (None,))
self.assertEqual(curs.fetchone(), None)
# fetchmany
curs.execute('select null')
self.assertEqual(curs.fetchmany(), [(None,)])
self.assertEqual(curs.fetchmany(), [])
curs.execute('select null')
self.assertEqual(curs.fetchmany(2), [(None,)])
self.assertEqual(curs.fetchmany(2), [])
# fetchall
curs.execute('select null')
self.assertEqual(curs.fetchall(), [(None,)])
self.assertEqual(curs.fetchall(), [])
# multiple rows
curs.execute('create table x ( y text )')
curs.execute('insert into x values (%s)', 'a')
curs.execute('insert into x values (%s)', 'b')
curs.execute('insert into x values (%s)', 'c')
curs.execute('select * from x')
self.assertEqual(curs.fetchall(), [('a',), ('b',), ('c',)])
curs.execute('select * from x')
self.assertEqual(curs.fetchmany(), [('a',)])
self.assertEqual(curs.fetchmany(), [('b',)])
self.assertEqual(curs.fetchmany(), [('c',)])
self.assertEqual(curs.fetchmany(), [])
curs.execute('select * from x')
self.assertEqual(curs.fetchmany(2), [('a',), ('b',)])
self.assertEqual(curs.fetchmany(2), [('c',)])
self.assertEqual(curs.fetchmany(2), [])
self.assertEqual(curs.arraysize, 1)
curs.arraysize = 2
self.assertEqual(curs.arraysize, 2)
curs.execute('select * from x')
self.assertEqual(curs.fetchmany(), [('a',), ('b',)])
self.assertEqual(curs.fetchmany(), [('c',)])
self.assertEqual(curs.fetchmany(), [])
db.rollback()
curs = db.cursor()
# multiple rows and cols
curs.execute('create table x ( y text, z int )')
curs.executemany('insert into x values (%s, %s)',
[('a', 1), ('b', 1), ('c', 1)])
curs.execute('select * from x')
self.assertEqual(curs.fetchall(),
[('a', 1), ('b', 1), ('c', 1)])
db.rollback()
curs = db.cursor()
curs.execute('create table x ( y text, z int )')
curs.executemany('insert into x values (%(a)s, %(b)s)',
[dict(a='a', b=1), dict(a='b', b=1), dict(a='c', b=1)])
curs.execute('select * from x')
self.assertEqual(curs.fetchall(),
[('a', 1), ('b', 1), ('c', 1)])
# close
curs.close()
self.assertRaises(ocpgdb.Error, curs.close)
self.assertRaises(ocpgdb.Error, curs.execute, 'select null')
self.assertRaises(ocpgdb.Error, curs.fetchone)
self.assertRaises(ocpgdb.Error, curs.fetchmany)
self.assertRaises(ocpgdb.Error, curs.fetchall)
def setUp(self):
self.db = ocpgdb.connect(**self.connect_args)
from time import time
"""
Compare performance of ocpgdb, pyPgSQL and psycopg2 for simple exec's
"""
def time_exec(db, cmd, *args):
st = time()
curs = db.cursor()
try:
for n in xrange(10000):
curs.execute(cmd, args)
finally:
curs.close()
return 1 / ((time() - st) / 10000)
import ocpgdb
from pyPgSQL import PgSQL
import psycopg2
print "no args"
print 'ocpgdb', time_exec(ocpgdb.connect(port=5433), 'select 1')
print 'pypgsql', time_exec(PgSQL.connect(port=5433), 'select 1')
print 'psycopg', time_exec(psycopg2.connect(port=5433), 'select 1')
print "one arg"
print 'ocpgdb', time_exec(ocpgdb.connect(port=5433), 'select %s', 1)
print 'pypgsql', time_exec(PgSQL.connect(port=5433), 'select %s', 1)
print 'psycopg', time_exec(psycopg2.connect(port=5433), 'select %s', 1)
def runTest(self):
db = ocpgdb.connect(**scratch_db)
curs = db.cursor()
# Make sure all the bits are there
self.assertHasAttr(curs, 'description')
self.assertHasAttr(curs, 'rowcount')
#self.assertHasAttr(curs, 'callproc') # Optional
self.assertHasAttr(curs, 'close')
self.assertHasAttr(curs, 'execute')
self.assertHasAttr(curs, 'executemany')
self.assertHasAttr(curs, 'fetchone')
self.assertHasAttr(curs, 'fetchmany')
self.assertHasAttr(curs, 'fetchall')
#self.assertHasAttr(curs, 'nextset') # Optional
self.assertHasAttr(curs, 'arraysize')
self.assertHasAttr(curs, 'setinputsizes') # Stub
self.assertHasAttr(curs, 'setoutputsize') # Stub
# Now test functionality
self.assertRaises(ocpgdb.Error, curs.fetchone)
self.assertEqual(curs.description, None)
self.assertEqual(curs.rowcount, -1)
# description
curs.execute('select null')
self.assertEqual(curs.description,
[('?column?', ocpgdb.pgoid.unknown, None, None, None, None, None)])
self.assertEqual(curs.rowcount, -1)
# execute
curs.execute('select null')
self.assertEqual(curs.fetchall(), [(None,)])
curs.execute('select null', ())
self.assertEqual(curs.fetchall(), [(None,)])
curs.execute('select null', [])
self.assertEqual(curs.fetchall(), [(None,)])
curs.execute('select null', {})
self.assertEqual(curs.fetchall(), [(None,)])
curs.execute('select null, 1')
self.assertEqual(curs.fetchall(), [(None, 1)])
curs.execute('select %s::int, %s::int', (None, 1))
self.assertEqual(curs.fetchall(), [(None, 1)])
curs.execute('select %(a)s::int, %(b)s::int', dict(a=None, b=1))
self.assertEqual(curs.fetchall(), [(None, 1)])
self.assertRaises(ocpgdb.Error, curs.execute,
'select %s::int, %s::int')
db.rollback()
self.assertRaises(ocpgdb.Error, curs.execute,
'select %s::int, %s::int', None)
db.rollback()
self.assertRaises(TypeError, curs.execute,
'select %s::int, %s::int', None, 1)
db.rollback()
self.assertRaises(ocpgdb.Error, curs.execute,
'select %s::int, %s::int', (None, None, None))
db.rollback()
self.assertRaises(ocpgdb.Error, curs.execute,
'select %s::int, %s::int', dict(a=None, b=1))
db.rollback()
self.assertRaises(ocpgdb.Error, curs.execute,
'select %(a)s::int, %(b)s::int', (None, 1))
db.rollback()
curs.execute('create table x ( y text )')
self.assertEqual(curs.rowcount, None)
self.assertRaises(ocpgdb.Error, curs.fetchall)
db.rollback()
# executemany
pass
# fetchone
curs.execute('select null')
self.assertEqual(curs.fetchone(), (None,))
self.assertEqual(curs.fetchone(), None)
# fetchmany
curs.execute('select null')
self.assertEqual(curs.fetchmany(), [(None,)])
self.assertEqual(curs.fetchmany(), [])
curs.execute('select null')
self.assertEqual(curs.fetchmany(2), [(None,)])
self.assertEqual(curs.fetchmany(2), [])
# fetchall
curs.execute('select null')
self.assertEqual(curs.fetchall(), [(None,)])
self.assertEqual(curs.fetchall(), [])
# multiple rows
curs.execute('create table x ( y text )')
curs.execute('insert into x values (%s)', 'a')
curs.execute('insert into x values (%s)', 'b')
curs.execute('insert into x values (%s)', 'c')
curs.execute('select * from x')
self.assertEqual(curs.fetchall(), [('a',), ('b',), ('c',)])
curs.execute('select * from x')
self.assertEqual(curs.fetchmany(), [('a',)])
self.assertEqual(curs.fetchmany(), [('b',)])
self.assertEqual(curs.fetchmany(), [('c',)])
self.assertEqual(curs.fetchmany(), [])
curs.execute('select * from x')
self.assertEqual(curs.fetchmany(2), [('a',), ('b',)])
self.assertEqual(curs.fetchmany(2), [('c',)])
self.assertEqual(curs.fetchmany(2), [])
self.assertEqual(curs.arraysize, 1)
curs.arraysize = 2
self.assertEqual(curs.arraysize, 2)
curs.execute('select * from x')
self.assertEqual(curs.fetchmany(), [('a',), ('b',)])
self.assertEqual(curs.fetchmany(), [('c',)])
self.assertEqual(curs.fetchmany(), [])
db.rollback()
curs = db.cursor()
# multiple rows and cols
curs.execute('create table x ( y text, z int )')
curs.executemany('insert into x values (%s, %s)',
[('a', 1), ('b', 1), ('c', 1)])
curs.execute('select * from x')
self.assertEqual(curs.fetchall(),
[('a', 1), ('b', 1), ('c', 1)])
db.rollback()
curs = db.cursor()
curs.execute('create table x ( y text, z int )')
curs.executemany('insert into x values (%(a)s, %(b)s)',
[dict(a='a', b=1), dict(a='b', b=1), dict(a='c', b=1)])
curs.execute('select * from x')
self.assertEqual(curs.fetchall(),
[('a', 1), ('b', 1), ('c', 1)])
# close
curs.close()
self.assertRaises(ocpgdb.Error, curs.close)
self.assertRaises(ocpgdb.Error, curs.execute, 'select null')
self.assertRaises(ocpgdb.Error, curs.fetchone)
self.assertRaises(ocpgdb.Error, curs.fetchmany)
self.assertRaises(ocpgdb.Error, curs.fetchall)
def setUp(self):
self.db = ocpgdb.connect(**self.connect_args)
"""
Simple framework for profiling py components of ocpgdb
"""
import hotshot
import hotshot.stats
import ocpgdb
db = ocpgdb.connect(port=5433)
def init():
curs = db.cursor()
try:
curs.execute('drop table iorate')
except ocpgdb.DatabaseError:
db.rollback()
curs.execute('create table iorate (a int, b int, c int, d int)')
curs.close()
def foo():
curs = db.cursor()
for i in xrange(10000):
curs.execute('insert into iorate values (%s, %s, %s, %s)',
(1000,1000,1000,1000))
curs.close()
db.rollback()
init()
if 0:
foo()
else:
prof = hotshot.Profile("scratch/ocpgdb.prof", 1, 1)
"""
Simple framework for profiling py components of ocpgdb
"""
import hotshot
import hotshot.stats
import ocpgdb
db = ocpgdb.connect(port=5433)
def init():
curs = db.cursor()
try:
curs.execute('drop table iorate')
except ocpgdb.DatabaseError:
db.rollback()
curs.execute('create table iorate (a int, b int, c int, d int)')
curs.close()
def foo():
curs = db.cursor()
for i in xrange(10000):
curs.execute('insert into iorate values (%s, %s, %s, %s)',
(1000, 1000, 1000, 1000))
curs.close()
db.rollback()
init()
if 0:
for word in words:
for s in shift:
d = word / s % 10
if digits or d:
digits.append(d)
return tuple(digits)
def decode(db, value):
data = list(ocpgdb.PgConnection.execute(db, "select '%s'::numeric" % value, ()))[0][0].value
words = struct.unpack('!%dh' % (len(data) / 2), data)
ndigits, weight, sign, dscale = words[:4]
words = words[4:]
print "ndigits %d, weight %d, sign %d, dscale %d" % (ndigits, weight, sign, dscale)
print words
assert ndigits == len(words)
if words:
digits = unpack_digits(words)
if sign == 16384:
sign = 1
cull = (4 - dscale) % 4
exp = (weight + 1 - ndigits) * 4 + cull
if cull:
digits = digits[:-cull]
else:
exp = -dscale
digits = (0,) * dscale
print digits, exp
return decimal.Decimal((sign, digits, exp))
db=ocpgdb.connect(database="andrewm",port=5433,use_mx_datetime=1)
from time import time
"""
Compare performance of ocpgdb, pyPgSQL and psycopg2 for simple exec's
"""
def time_exec(db, cmd, *args):
st = time()
curs = db.cursor()
try:
for n in xrange(10000):
curs.execute(cmd, args)
finally:
curs.close()
return 1 / ((time() - st) / 10000)
import ocpgdb
from pyPgSQL import PgSQL
import psycopg2
print "no args"
print 'ocpgdb', time_exec(ocpgdb.connect(port=5433), 'select 1')
print 'pypgsql', time_exec(PgSQL.connect(port=5433), 'select 1')
print 'psycopg', time_exec(psycopg2.connect(port=5433), 'select 1')
print "one arg"
print 'ocpgdb', time_exec(ocpgdb.connect(port=5433), 'select %s', 1)
print 'pypgsql', time_exec(PgSQL.connect(port=5433), 'select %s', 1)
print 'psycopg', time_exec(psycopg2.connect(port=5433), 'select %s', 1)
