mirror of
https://github.com/mariadb-corporation/mariadb-connector-python.git
synced 2025-08-11 02:43:15 +00:00
378 lines
12 KiB
Python
378 lines
12 KiB
Python
#!/usr/bin/env python -O
|
|
|
|
import mariadb
|
|
import datetime
|
|
import unittest
|
|
import collections
|
|
|
|
class CursorTest(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
self.connection= mariadb.connection(default_file='default.cnf')
|
|
|
|
def tearDown(self):
|
|
del self.connection
|
|
|
|
def test_date(self):
|
|
cursor= self.connection.cursor()
|
|
cursor.execute("CREATE OR REPLACE TABLE t1(c1 TIMESTAMP(6), c2 TIME(6), c3 DATETIME(6), c4 DATE)")
|
|
t= datetime.datetime(2018,6,20,12,22,31,123456)
|
|
c1= t
|
|
c2= t.time()
|
|
c3= t
|
|
c4= t.date()
|
|
cursor.execute("INSERT INTO t1 VALUES (?,?,?,?)", (c1, c2, c3, c4))
|
|
|
|
cursor.execute("SELECT c1,c2,c3,c4 FROM t1")
|
|
row= cursor.fetchone()
|
|
self.assertEqual(row[0],c1)
|
|
self.assertEqual(row[1],c2)
|
|
self.assertEqual(row[2],c3)
|
|
self.assertEqual(row[3],c4)
|
|
cursor.close()
|
|
|
|
def test_numbers(self):
|
|
cursor= self.connection.cursor()
|
|
cursor.execute("CREATE OR REPLACE TABLE t1 (a tinyint unsigned, b smallint unsigned, c mediumint unsigned, d int unsigned, e bigint unsigned, f double)")
|
|
c1= 4
|
|
c2= 200
|
|
c3= 167557
|
|
c4= 28688817
|
|
c5= 7330133222578
|
|
c6= 3.1415925
|
|
|
|
cursor.execute("insert into t1 values (?,?,?,?,?,?)", (c1,c2,c3,c4,c5,c6))
|
|
|
|
cursor.execute("select * from t1")
|
|
row= cursor.fetchone()
|
|
self.assertEqual(row[0],c1)
|
|
self.assertEqual(row[1],c2)
|
|
self.assertEqual(row[2],c3)
|
|
self.assertEqual(row[3],c4)
|
|
self.assertEqual(row[4],c5)
|
|
self.assertEqual(row[5],c6)
|
|
del cursor
|
|
|
|
def test_string(self):
|
|
cursor= self.connection.cursor()
|
|
cursor.execute("CREATE OR REPLACE TABLE t1 (a char(5), b varchar(100), c tinytext, d mediumtext, e text, f longtext)");
|
|
|
|
c1= "12345";
|
|
c2= "The length of this text is < 100 characters"
|
|
c3= "This should also fit into tinytext which has a maximum of 255 characters"
|
|
c4= 'a' * 1000;
|
|
c5= 'b' * 6000;
|
|
c6= 'c' * 67000;
|
|
|
|
cursor.execute("INSERT INTO t1 VALUES (?,?,?,?,?,?)", (c1,c2,c3,c4,c5,c6))
|
|
|
|
cursor.execute("SELECT * from t1")
|
|
row= cursor.fetchone()
|
|
self.assertEqual(row[0],c1)
|
|
self.assertEqual(row[1],c2)
|
|
self.assertEqual(row[2],c3)
|
|
self.assertEqual(row[3],c4)
|
|
self.assertEqual(row[4],c5)
|
|
self.assertEqual(row[5],c6)
|
|
del cursor
|
|
|
|
def test_blob(self):
|
|
cursor= self.connection.cursor()
|
|
cursor.execute("CREATE OR REPLACE TABLE t1 (a tinyblob, b mediumblob, c blob, d longblob)")
|
|
|
|
c1= b'a' * 100;
|
|
c2= b'b' * 1000;
|
|
c3= b'c' * 10000;
|
|
c4= b'd' * 100000;
|
|
|
|
a= (None, None, None, None)
|
|
cursor.execute("INSERT INTO t1 VALUES (?,?,?,?)", (c1, c2, c3, c4))
|
|
|
|
cursor.execute("SELECT * FROM t1")
|
|
row= cursor.fetchone()
|
|
self.assertEqual(row[0],c1)
|
|
self.assertEqual(row[1],c2)
|
|
self.assertEqual(row[2],c3)
|
|
self.assertEqual(row[3],c4)
|
|
del cursor
|
|
|
|
def test_fetchmany(self):
|
|
cursor= self.connection.cursor()
|
|
cursor.execute("CREATE OR REPLACE TABLE t1 (id int, name varchar(64), city varchar(64))");
|
|
params= [(1, u"Jack", u"Boston"),
|
|
(2, u"Martin", u"Ohio"),
|
|
(3, u"James", u"Washington"),
|
|
(4, u"Rasmus", u"Helsinki"),
|
|
(5, u"Andrey", u"Sofia")]
|
|
cursor.executemany("INSERT INTO t1 VALUES (?,?,?)", params);
|
|
|
|
#test Errors
|
|
# a) if no select was executed
|
|
self.assertRaises(mariadb.Error, cursor.fetchall)
|
|
#b ) if cursor was not executed
|
|
del cursor
|
|
cursor= self.connection.cursor()
|
|
self.assertRaises(mariadb.Error, cursor.fetchall)
|
|
|
|
cursor.execute("SELECT id, name, city FROM t1 ORDER BY id")
|
|
self.assertEqual(0, cursor.rowcount)
|
|
row = cursor.fetchall()
|
|
self.assertEqual(row, params)
|
|
self.assertEqual(5, cursor.rowcount)
|
|
|
|
cursor.execute("SELECT id, name, city FROM t1 ORDER BY id")
|
|
self.assertEqual(0, cursor.rowcount)
|
|
|
|
row= cursor.fetchmany(1)
|
|
self.assertEqual(row,[params[0]])
|
|
self.assertEqual(1, cursor.rowcount)
|
|
|
|
row= cursor.fetchmany(2)
|
|
self.assertEqual(row,([params[1], params[2]]))
|
|
self.assertEqual(3, cursor.rowcount)
|
|
|
|
cursor.arraysize= 1
|
|
row= cursor.fetchmany()
|
|
self.assertEqual(row,[params[3]])
|
|
self.assertEqual(4, cursor.rowcount)
|
|
|
|
cursor.arraysize= 2
|
|
row= cursor.fetchmany()
|
|
self.assertEqual(row,[params[4]])
|
|
self.assertEqual(5, cursor.rowcount)
|
|
del cursor
|
|
|
|
def test1_multi_result(self):
|
|
cursor= self.connection.cursor()
|
|
sql= """
|
|
CREATE OR REPLACE PROCEDURE p1()
|
|
BEGIN
|
|
SELECT 1 FROM DUAL;
|
|
SELECT 2 FROM DUAL;
|
|
END
|
|
"""
|
|
cursor.execute(sql)
|
|
cursor.execute("call p1()")
|
|
row= cursor.fetchone()
|
|
self.assertEqual(row[0], 1)
|
|
cursor.nextset()
|
|
row= cursor.fetchone()
|
|
self.assertEqual(row[0], 2)
|
|
del cursor
|
|
|
|
def test_buffered(self):
|
|
cursor= self.connection.cursor()
|
|
cursor.execute("SELECT 1 UNION SELECT 2 UNION SELECT 3", buffered=True)
|
|
self.assertEqual(cursor.rowcount, 3)
|
|
cursor.scroll(1)
|
|
row= cursor.fetchone()
|
|
self.assertEqual(row[0],2)
|
|
del cursor
|
|
|
|
def test_xfield_types(self):
|
|
cursor= self.connection.cursor()
|
|
fieldinfo= mariadb.fieldinfo()
|
|
cursor.execute("CREATE OR REPLACE TABLE t1 (a tinyint not null auto_increment primary key, b smallint, c int, d bigint, e float, f decimal, g double, h char(10), i varchar(255), j blob, index(b))");
|
|
info= cursor.description
|
|
self.assertEqual(info, None)
|
|
cursor.execute("SELECT * FROM t1")
|
|
info= cursor.description
|
|
self.assertEqual(fieldinfo.type(info[0]), "TINY")
|
|
self.assertEqual(fieldinfo.type(info[1]), "SHORT")
|
|
self.assertEqual(fieldinfo.type(info[2]), "LONG")
|
|
self.assertEqual(fieldinfo.type(info[3]), "LONGLONG")
|
|
self.assertEqual(fieldinfo.type(info[4]), "FLOAT")
|
|
self.assertEqual(fieldinfo.type(info[5]), "NEWDECIMAL")
|
|
self.assertEqual(fieldinfo.type(info[6]), "DOUBLE")
|
|
self.assertEqual(fieldinfo.type(info[7]), "STRING")
|
|
self.assertEqual(fieldinfo.type(info[8]), "VAR_STRING")
|
|
self.assertEqual(fieldinfo.type(info[9]), "BLOB")
|
|
self.assertEqual(fieldinfo.flag(info[0]), "NOT_NULL | PRIMARY_KEY | AUTO_INCREMENT | NUMERIC")
|
|
self.assertEqual(fieldinfo.flag(info[1]), "PART_KEY | NUMERIC")
|
|
self.assertEqual(fieldinfo.flag(info[9]), "BLOB | BINARY")
|
|
del cursor
|
|
|
|
def test_named_tuple(self):
|
|
cursor= self.connection.cursor(named_tuple=1)
|
|
cursor.execute("CREATE OR REPLACE TABLE t1 (id int, name varchar(64), city varchar(64))");
|
|
params= [(1, u"Jack", u"Boston"),
|
|
(2, u"Martin", u"Ohio"),
|
|
(3, u"James", u"Washington"),
|
|
(4, u"Rasmus", u"Helsinki"),
|
|
(5, u"Andrey", u"Sofia")]
|
|
cursor.executemany("INSERT INTO t1 VALUES (?,?,?)", params);
|
|
cursor.execute("SELECT * FROM t1 ORDER BY id")
|
|
row= cursor.fetchone()
|
|
|
|
self.assertEqual(cursor.statement, "SELECT * FROM t1 ORDER BY id")
|
|
self.assertEqual(row.id, 1)
|
|
self.assertEqual(row.name, "Jack")
|
|
self.assertEqual(row.city, "Boston")
|
|
del cursor
|
|
|
|
def test_laststatement(self):
|
|
cursor= self.connection.cursor(named_tuple=1)
|
|
cursor.execute("CREATE OR REPLACE TABLE t1 (id int, name varchar(64), city varchar(64))");
|
|
self.assertEqual(cursor.statement, "CREATE OR REPLACE TABLE t1 (id int, name varchar(64), city varchar(64))")
|
|
|
|
params= [(1, u"Jack", u"Boston"),
|
|
(2, u"Martin", u"Ohio"),
|
|
(3, u"James", u"Washington"),
|
|
(4, u"Rasmus", u"Helsinki"),
|
|
(5, u"Andrey", u"Sofia")]
|
|
cursor.executemany("INSERT INTO t1 VALUES (?,?,?)", params);
|
|
cursor.execute("SELECT * FROM t1 ORDER BY id")
|
|
self.assertEqual(cursor.statement, "SELECT * FROM t1 ORDER BY id")
|
|
del cursor
|
|
|
|
def test_multi_cursor(self):
|
|
cursor= self.connection.cursor()
|
|
cursor1= self.connection.cursor(cursor_type=1)
|
|
cursor2= self.connection.cursor(cursor_type=1)
|
|
|
|
cursor.execute("CREATE OR REPLACE TABLE t1 (a int)")
|
|
cursor.execute("INSERT INTO t1 VALUES (1),(2),(3),(4),(5),(6),(7),(8)")
|
|
del cursor
|
|
|
|
cursor1.execute("SELECT a FROM t1 ORDER BY a")
|
|
cursor2.execute("SELECT a FROM t1 ORDER BY a DESC")
|
|
|
|
for i in range (0,8):
|
|
self.assertEqual(cursor1.rownumber, i)
|
|
row1= cursor1.fetchone()
|
|
row2= cursor2.fetchone()
|
|
self.assertEqual(cursor1.rownumber, cursor2.rownumber)
|
|
self.assertEqual(row1[0]+row2[0], 9)
|
|
|
|
del cursor1
|
|
del cursor2
|
|
|
|
def test_connection_attr(self):
|
|
cursor= self.connection.cursor()
|
|
self.assertEqual(cursor.connection, self.connection)
|
|
del cursor
|
|
|
|
def test_dbapi_type(self):
|
|
cursor= self.connection.cursor()
|
|
cursor.execute("CREATE OR REPLACE TABLE t1 (a int, b varchar(20), c blob, d datetime, e decimal)")
|
|
cursor.execute("INSERT INTO t1 VALUES (1, 'foo', 'blabla', now(), 10.2)");
|
|
cursor.execute("SELECT * FROM t1 ORDER BY a")
|
|
expected_typecodes= [
|
|
mariadb.NUMBER,
|
|
mariadb.STRING,
|
|
mariadb.BINARY,
|
|
mariadb.DATETIME,
|
|
mariadb.NUMBER
|
|
]
|
|
row= cursor.fetchone()
|
|
typecodes= [row[1] for row in cursor.description]
|
|
self.assertEqual(expected_typecodes, typecodes)
|
|
del cursor
|
|
|
|
def test_tuple(self):
|
|
cursor= self.connection.cursor()
|
|
cursor.execute("CREATE OR REPLACE TABLE dyncol1 (a blob)");
|
|
tpl=(1,2,3)
|
|
cursor.execute("INSERT INTO dyncol1 VALUES (?)", tpl);
|
|
del cursor
|
|
|
|
def test_indicator(self):
|
|
cursor= self.connection.cursor()
|
|
cursor.execute("CREATE OR REPLACE TABLE ind1 (a int, b int default 2,c int)");
|
|
vals= (mariadb.indicator_null, mariadb.indicator_default, 3)
|
|
cursor.executemany("INSERT INTO ind1 VALUES (?,?,?)", [vals])
|
|
cursor.execute("SELECT a, b, c FROM ind1")
|
|
row= cursor.fetchone()
|
|
self.assertEqual(row[0], None)
|
|
self.assertEqual(row[1], 2)
|
|
self.assertEqual(row[2], 3)
|
|
|
|
def test_tuple(self):
|
|
cursor= self.connection.cursor()
|
|
cursor.execute("CREATE OR REPLACE TABLE dyncol1 (a blob)");
|
|
t= datetime.datetime(2018,6,20,12,22,31,123456)
|
|
val=([1,t,3,(1,2,3)],)
|
|
cursor.execute("INSERT INTO dyncol1 VALUES (?)", val);
|
|
cursor.execute("SELECT a FROM dyncol1")
|
|
row= cursor.fetchone()
|
|
self.assertEqual(row,val);
|
|
del cursor
|
|
|
|
def test_set(self):
|
|
cursor= self.connection.cursor()
|
|
cursor.execute("CREATE OR REPLACE TABLE dyncol1 (a blob)");
|
|
t= datetime.datetime(2018,6,20,12,22,31,123456)
|
|
a= collections.OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1), ('4',3), (4,4)])
|
|
val=([1,t,3,(1,2,3), {1,2,3},a],)
|
|
cursor.execute("INSERT INTO dyncol1 VALUES (?)", val);
|
|
cursor.execute("SELECT a FROM dyncol1")
|
|
row= cursor.fetchone()
|
|
self.assertEqual(row,val);
|
|
del cursor
|
|
|
|
def test_reset(self):
|
|
cursor= self.connection.cursor()
|
|
cursor.execute("SELECT 1 UNION SELECT 2", buffered=False)
|
|
cursor.execute("SELECT 1 UNION SELECT 2")
|
|
del cursor
|
|
|
|
def test_fake_pickle(self):
|
|
cursor= self.connection.cursor()
|
|
cursor.execute("create or replace table t1 (a blob)")
|
|
k=bytes([0x80,0x03,0x00,0x2E])
|
|
cursor.execute("insert into t1 values (?)", (k,))
|
|
cursor.execute("select * from t1");
|
|
row= cursor.fetchone()
|
|
self.assertEqual(row[0],k)
|
|
del cursor
|
|
|
|
def test_no_result(self):
|
|
cursor= self.connection.cursor()
|
|
cursor.execute("set @a:=1")
|
|
try:
|
|
row= cursor.fetchone()
|
|
except mariadb.ProgrammingError:
|
|
pass
|
|
del cursor
|
|
|
|
def test_collate(self):
|
|
cursor= self.connection.cursor()
|
|
cursor.execute("CREATE TABLE IF NOT EXISTS `tt` (`test` varchar(500) COLLATE utf8mb4_unicode_ci NOT NULL) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci")
|
|
cursor.execute("SET NAMES utf8mb4")
|
|
cursor.execute("SELECT * FROM `tt` WHERE `test` LIKE 'jj' COLLATE utf8mb4_unicode_ci")
|
|
del cursor
|
|
|
|
def test_conpy_8(self):
|
|
cursor=self.connection.cursor()
|
|
sql= """
|
|
CREATE OR REPLACE PROCEDURE p1()
|
|
BEGIN
|
|
SELECT 1 FROM DUAL UNION SELECT 0 FROM DUAL;
|
|
SELECT 2 FROM DUAL;
|
|
END
|
|
"""
|
|
cursor.execute(sql)
|
|
cursor.execute("call p1()")
|
|
|
|
cursor.nextset()
|
|
row= cursor.fetchone()
|
|
self.assertEqual(row[0],2);
|
|
del cursor
|
|
|
|
def test_conpy_7(self):
|
|
cursor=self.connection.cursor()
|
|
stmt= "SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4"
|
|
cursor.execute(stmt, buffered=True)
|
|
cursor.scroll(2, mode='relative')
|
|
row= cursor.fetchone()
|
|
self.assertEqual(row[0],3)
|
|
cursor.scroll(-2, mode='relative')
|
|
row= cursor.fetchone()
|
|
print(row)
|
|
del cursor
|
|
|
|
def test_compy_9(self):
|
|
cursor=self.connection.cursor(buffered=True)
|
|
cursor.execute("SELECT 'utf8mb4', 123.5678")
|
|
print(cursor.description)
|