def insert_into(connection: MySQLConnection, table, ip_ranges: Deque[CIDR], comment: str, delete_old: bool = False): try: count_where_list = f"SELECT COUNT(*) FROM {table} WHERE list = %s" cursor = connection.cursor() cursor.execute(count_where_list, (FIREWALL_LIST,)) old_count = cursor.fetchone()[0] cursor.close() if not delete_old: print(f"Před vložením nových dat je v tabulce {table} {old_count} řádků.") else: print(f"Z tabulky {table} bude odstraněno {old_count} řádků.") delete_where_list = f"DELETE FROM {table} WHERE list = %s" cursor = connection.cursor() cursor.execute(delete_where_list, (FIREWALL_LIST,)) cursor.close() insert_query = (f"INSERT INTO {table} (address, mask, list, comment, disabled) " "VALUES (%s, %s, %s, %s, %s)") cursor = connection.cursor() cursor.executemany(insert_query, [(ip.ip, ip.suffix, FIREWALL_LIST, comment, 0) for ip in ip_ranges]) connection.commit() cursor.close() print(f"Bylo vloženo {len(ip_ranges)} řádků.") except mysql.connector.Error: connection.rollback() raise
def query3(conn: MySQLConnection): def preload_data(): return # no need to preload data, use the sample data from the database preload_data() cursor = conn.cursor() sql = "SELECT (SELECT COUNT(DISTINCT cplate) FROM rent_records " \ "WHERE (DATE(date_from) BETWEEN DATE(%s) AND DATE(%s)) AND " \ "(TIME(date_from) BETWEEN TIME(%s) AND TIME(%s)))/(SELECT COUNT(*) FROM cars) AS Morning, " \ "(SELECT COUNT(DISTINCT cplate) FROM rent_records " \ "WHERE (DATE(date_from) BETWEEN DATE(%s) AND DATE(%s)) AND " \ "(TIME(date_from) BETWEEN TIME(%s) AND TIME(%s)))/(SELECT COUNT(*) FROM cars) AS Afternoon, " \ "(SELECT COUNT(DISTINCT cplate) FROM rent_records " \ "WHERE (DATE(date_from) BETWEEN DATE(%s) AND DATE(%s)) AND " \ "(TIME(date_from) BETWEEN TIME(%s) AND TIME(%s)))/(SELECT COUNT(*) FROM cars) AS Evening" d1 = getstr(datetime(2018, 9, 1)) d2 = getstr(datetime(2018, 9, 7)) mor1 = time(7, 0) mor2 = time(10, 0) aft1 = time(12, 0) aft2 = time(14, 0) eve1 = time(17, 0) eve2 = time(19, 0) value = (d1, d2, mor1, mor2, d1, d2, aft1, aft2, d1, d2, eve1, eve2) cursor.execute(sql, value) return cursor.fetchall(), [i[0] for i in cursor.description]
def UpdateRecord(db_connection: MySQLConnection, record: Record): db_cursor = db_connection.cursor() sql = "UPDATE records SET title=%s, summary=%s WHERE full_serial_number = %s" values = (record.title, record.summary, record.full_serial_number) db_cursor.execute(sql, values) db_connection.commit()
def query2(conn: MySQLConnection): cursor = conn.cursor() date = datetime(2018, 10, 5, 0, 0, 0) def preload_data(): # get five charging stations to be used for statistics sql = "SELECT * FROM charging_stations LIMIT 5" cursor.execute(sql) # get ids and # of sockets of five stations data = [station for station in cursor.fetchall()] rand_stations_id = [x[0] for x in data] no_of_socket = [x[3] for x in data] sql = "INSERT INTO charging_station_sockets (station_id, no_of_available_sockets, date_time) " \ "VALUES (%s, %s, %s)" date_times = [date + timedelta(hours=x) for x in range(24)] for i in range(len(rand_stations_id)): for date_time in date_times: value = (rand_stations_id[i], randint(0, no_of_socket[i]), getstr(date_time)) cursor.execute(sql, value) conn.commit() preload_data() query = "SELECT CONCAT(HOUR(css.date_time), 'h-', HOUR(css.date_time) + 1, 'h') AS Period, " \ "SUM(cs.total_no_of_sockets - css.no_of_available_sockets) AS OccupiedSockets " \ "FROM charging_station_sockets AS css " \ "INNER JOIN charging_stations AS cs ON css.station_id = cs.id " \ "WHERE DATE(css.date_time) = DATE(%s) GROUP BY TIME(css.date_time)" val = (getstr(date), ) cursor.execute(query, val) return cursor.fetchall(), [i[0] for i in cursor.description]
def UpdateBusinessUnit(db_connection: MySQLConnection, business_unit: int): db_cursor = db_connection.cursor() sql = "UPDATE business_units SET title=%s,summary=%s WHERE business_code = %s" values = (business_unit.title, business_unit.summary, business_unit.specific_code) db_cursor.execute(sql, values) db_connection.commit()
def CreateNewRecord(db_connection: MySQLConnection, serial_number:int, status:str, title:str, record_custodian_state:str, record_revision_state:str, record_link_state:str, record_sow_state:str, record_issue_date_state:str, record_effective_date_state:str, record_reaffirmation_date_state:str, record_protection_lvl_state:str, record_ec_state:bool, record_permit_state:str, record_ecl_state:str, record_eccn_state:str, record_usml_state:str, record_cg_state:str, record_us_exemption_state:str, record_ca_exemption_state:str, record_exp_date_state:str, summary:str ="NA" ): db_cursor = db_connection.cursor() str_code = str(serial_number) business_series = str_code[0]+"0" business_code = str_code[0:2] document_code = str_code[2:4] sql = "INSERT INTO records (business_series_index, business_code, document_code, full_serial_number, status, title, custodian, revision, \ link, sow_no, issue_date, effective_date, reaffirmation_date, protection_lvl, ec_technical_data, permit, ecl, eccn, usml, cg, us_exemption, \ ca_exemption, exp_date, summary) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) " value = (business_series, business_code, document_code, str_code, status, title, record_custodian_state, record_revision_state, record_link_state, record_sow_state, record_issue_date_state, record_effective_date_state, record_reaffirmation_date_state, record_protection_lvl_state, record_ec_state, record_permit_state, record_ecl_state, record_eccn_state, record_usml_state, record_cg_state, record_us_exemption_state, record_ca_exemption_state, record_exp_date_state, summary) db_cursor.execute(sql, value) db_connection.commit()
def UpdateDocumentType(db_connection: MySQLConnection, document_type: DocumentType): db_cursor = db_connection.cursor() sql = "UPDATE document_types SET title=%s, summary=%s WHERE document_code = %s" values = (document_type.title, document_type.summary, document_type.document_code) db_cursor.execute(sql, values) db_connection.commit()
def prepare_business_series(db_connection: MySQLConnection): db_cursor = db_connection.cursor() sql = "INSERT INTO business_series (business_series_index, title) VALUES (%s, %s)" val = [('10', 'Corporate'), ('20', 'Export Controls'), ('30', 'Project Controls'), ('40', 'Engineering'), ('50', 'Operations'), ('60', 'IT'), ('70', 'QMS'), ('80', 'unassigned'), ('90', 'Office General')] db_cursor.executemany(sql, val) db_connection.commit()
def UpdateRecord(db_connection: MySQLConnection, record: Record): db_cursor = db_connection.cursor() sql = "UPDATE records SET status=%s, title=%s, custodian=%s, revision=%s, link=%s, sow_no=%s, \ issue_date=%s, effective_date=%s, reaffirmation_date=%s, protection_lvl=%s, ec_technical_data=%s, permit=%s, ecl=%s, eccn=%s, usml=%s, cg=%s, \ us_exemption=%s, ca_exemption=%s, exp_date=%s, summary=%s WHERE full_serial_number = %s" values = (record.status, record.title, record.custodian, record.revision, record.link, record.sow_no, record.issue_date, record.effective_date,\ record.reaffirmation_date, record.protection_lvl, record.ec_technical_data, record.permit, record.ecl, record.eccn, record.usml, record.cg, \ record.us_exemption, record.ca_exemption, record.exp_date, record.summary, record.full_serial_number) db_cursor.execute(sql,values) db_connection.commit()
def CreateNewDocumentType(db_connection: MySQLConnection, document_code: int, title: str, summary: str = "NA"): db_cursor = db_connection.cursor() sql = "INSERT INTO document_types (document_code, title, summary) VALUES (%s, %s, %s) " value = (str(document_code), title, summary) db_cursor.execute(sql, value) db_connection.commit()
class MySQL: def __init__(self): self.host = "localhost" self.user = "******" self.password = "******" self.database = "RaspberryData" def Conexion(self): try self.mydb = MySQLConnection( host=self.host, user=self.user, password=self.password, database=self.database ) except Exception as e self.mydb = MySQLConnection( host="localhost", user="******", password="******", database="RaspberryData" ) return "Conexion a MySQL exitosa" # DHT---------------------------------------------------------------- def guardarDatos(self, data): self.sql = "insert into Sensors (IDName, Data, Type) values (%s, %s, %s)" self.mycursor = self.mydb.cursor() self.mycursor.execute(self.sql, (data['name'], str(data['data']), data['type'])) self.mydb.commit() def getSensors(self): self.sql = "select * from sensors_inst" try: self.mycursor = self.mydb.cursor() self.mycursor.execute(self.sql) data = self.mycursor.fetchall() return data except Exception as e: raise e
class MysqlImport(SqlImport): BATCH_SIZE = 1000 def __init__(self, host, port, user, password, db, log): self.context = MySQLConnection(host=host, port=port, user=user, password=password, database=db) self.cursor = self.context.cursor() self.log = log def run(self, parser, limit=0): lines = [] keys = [] pbar = tqdm(total=parser.get_size()) count = 0 while limit == 0 or count <= limit: line = parser.parse_line() if line: lines.append(tuple(line.values())) keys = line.keys() count += 1 if len(lines) >= self.BATCH_SIZE or not line: try: self.cursor.executemany(self.build_insert(parser, keys), lines) pbar.update(len(lines)) except IntegrityError as e: self.log.error(str(e)) lines = [] if not line: break self.context.commit() def run_script(self, filepath): for line in open(filepath): self.cursor.execute(line) self.log.info('Ran script', filepath) def truncate_table(self, table): self.cursor.execute('TRUNCATE TABLE ' + table) def close(self): self.context.commit() self.cursor.close() self.context.close()
def CreateNewBusinessUnit(db_connection: MySQLConnection, title: str, code: int, summary: str = "NA"): db_cursor = db_connection.cursor() str_code = str(code) business_series = str_code[0] + "0" sql = "INSERT INTO business_units (title, summary, business_code, business_series_index) VALUES (%s, %s, %s, %s) " value = (title, summary, str_code, business_series) db_cursor.execute(sql, value) db_connection.commit()
def __init__(self, oriData: NewFileProcessor, session: MySQLConnection, date: str) -> None: """ 读入数据:从正式处理程序里读取DataFrame格式的数据 """ assert isinstance(oriData, NewFileProcessor) assert isinstance(oriData.insertDataFrame, DataFrame) self.oriData = oriData.insertDataFrame.copy() # 要上传的数据(没有转化格式) self.oriData_rows, self.oriData_cols = self.oriData.shape # 获取数据尺寸 self.path = oriData.fileFullPath self.session = session # 数据库连接 self.cur = session.cursor() # 数据库游标 self.startDate = date # 第一周对应的日期
def query8(conn: MySQLConnection): cursor = conn.cursor() start_date = datetime(2018, 8, 1) end_date = datetime(2018, 8, 31) def preload_data(): # get one customer_id to demostrate how our query works sql = "SELECT id FROM customers WHERE username = %s" val = ("Liza", ) cursor.execute(sql, val) customer_id = cursor.fetchone()[0] # get 10 car plates to add them to renting and charge records sql = "SELECT plate FROM cars ORDER BY RAND() LIMIT 10" cursor.execute(sql) cplates = [car[0] for car in cursor.fetchall()] # get one random charging station id to add it to charge records sql = "SELECT id FROM charging_stations ORDER BY RAND() LIMIT 1" cursor.execute(sql) station_id = cursor.fetchone()[0] rent_sql = "INSERT INTO rent_records (date_from, date_to, cid, cplate, distance) " \ "VALUES (%s, %s, %s, %s, %s)" charge_sql = "INSERT INTO charge_records (date_time, sid, cplate, price) " \ "VALUES (%s, %s, %s, %s)" for cplate in cplates: # insert rent record date_from = get_fake_date_time(start=start_date, end=end_date - timedelta(days=1, hours=3)) date_to = get_fake_date_time(start=date_from, end=date_from + timedelta(hours=2, minutes=59)) val = (getstr(date_from), getstr(date_to), customer_id, cplate, randint(10, 100)) cursor.execute(rent_sql, val) # insert charge record the same day of rent record date_time = get_fake_date_time(start=date_from.date(), end=date_from.date() + timedelta(hours=12)) val = (getstr(date_time), station_id, cplate, randint(10, 100)) cursor.execute(charge_sql, val) conn.commit() preload_data() query = "SELECT rr.cid AS CustomerId, COUNT(cr.id) AS Amount FROM rent_records AS rr " \ "INNER JOIN charge_records AS cr ON rr.cplate = cr.cplate " \ "AND DATE(rr.date_from) = DATE(cr.date_time) " \ "WHERE DATE(cr.date_time) BETWEEN DATE(%s) AND DATE(%s) GROUP BY rr.cid" value = (start_date, end_date) cursor.execute(query, value) return cursor.fetchall(), [i[0] for i in cursor.description]
def query9(conn: MySQLConnection): def preload_data(): pass # no need to preload data, use the sample data from the database preload_data() cursor = conn.cursor() sql = "SELECT wid AS WorkshopID, type AS CarPartType, MAX(amount) AS Amount " \ "FROM (SELECT D.wid, D.type, SUM(D.amount) AS amount " \ "FROM (SELECT d.amount, o.wid, p.type FROM order_details as d " \ "INNER JOIN orders AS o ON d.order_id = o.id " \ "INNER JOIN car_parts AS p ON p.trade_name = d.trade_name AND p.pid = d.pid) AS D " \ "GROUP BY D.wid, D.type ORDER BY Amount DESC) AS D2 GROUP BY WorkshopID" cursor.execute(sql) return cursor.fetchall(), [i[0] for i in cursor.description]
def query10(conn: MySQLConnection): def preload_data(): pass # no need to preload data, use the sample data from the database preload_data() cursor = conn.cursor() sql = "SELECT cplate AS CarPlate, AVG(day_price) AS AvgPrice " \ "FROM (SELECT cplate, SUM(price) AS day_price " \ "FROM ((SELECT date_time, price, cplate FROM repair_records) UNION " \ "(SELECT date_time, price, cplate FROM charge_records)) AS records " \ "GROUP BY DATE(date_time), cplate) AS prices " \ "GROUP BY cplate ORDER BY AvgPrice DESC LIMIT 1" cursor.execute(sql) return cursor.fetchall(), [i[0] for i in cursor.description]
class MySQL: def __init__(self): self.host="localhost" self.user="******" self.password="******" self.database="examen" def Conexion(self): self.mydb = MySQLConnection( host=self.host, user=self.user, password=self.password, database=self.database ) return "Conexion a MySQL exitosa" #DHT---------------------------------------------------------------- def guardarDatos(self,datos): self.sql = "insert into SensorDHT (temperatura, humedad, fechaLectura) values (%s, %s, %s)" self.mycursor = self.mydb.cursor() self.mycursor.execute(self.sql,datos) self.mydb.commit() #PIR---------------------------------------------------------------- def guardarDatosPIR(self,estado): self.sql = "insert into SensorPIR (estado,fechaLectura) values (%s,%s)" self.mycursor = self.mydb.cursor() self.mycursor.execute(self.sql,estado) self.mydb.commit() #HCR---------------------------------------------------------------- def guardarDatosHCR(self,distancia): self.sql = "insert into SensorHCR (distancia,fechaLectura) values (%s,%s)" self.mycursor = self.mydb.cursor() self.mycursor.execute(self.sql,distancia) self.mydb.commit()
def prepare_document_types(db_connection: MySQLConnection): db_cursor = db_connection.cursor() sql = "INSERT INTO document_types (document_code, title, summary) VALUES (%s, %s, %s)" val = [('0', 'Template', 'NA'), ('01', 'Manuals/Policies', 'NA'), ('02', 'Workflow', 'NA'), ('03', 'Process/Procedure', 'NA'), ('04', 'Work Instruction', 'NA'), ('05', 'Form/Checklist', 'NA'), ('06', 'Presentation', 'NA'), ('07', 'Specification', 'NA'), ('08', 'Report', 'NA'), ('09', 'Drawing', 'NA'), ('10', 'Cover Sheet', 'NA'), ('97', 'Logs', 'NA'), ('98', 'Emails and Communication Records', 'NA'), ('99', 'Non-Communication Records', 'NA')] db_cursor.executemany(sql, val) db_connection.commit()
def CreateNewRecord(db_connection: MySQLConnection, serial_number: int, title: str, summary: str = "NA"): db_cursor = db_connection.cursor() str_code = str(serial_number) business_series = str_code[0] + "0" business_code = str_code[0:2] document_code = str_code[2:4] sql = "INSERT INTO records (business_series_index, business_code, document_code, full_serial_number, title, summary) VALUES (%s, %s, %s, %s, %s, %s) " value = (business_series, business_code, document_code, str_code, title, summary) db_cursor.execute(sql, value) db_connection.commit()
def query7(conn: MySQLConnection): def preload_data(): pass # no need to preload data, use the sample data from the database start_first_month = datetime(2018, 8, 1) end_third_month = datetime(2018, 10, 31) preload_data() cursor = conn.cursor() # create variable in database - 10% of amount of all cars sql = "SELECT 0.1 * COUNT(*) FROM cars" cursor.execute(sql) limit = int(cursor.fetchone()[0]) sql = "SELECT cplate AS CarPlate, COUNT(rr.id) AS RentAmount FROM rent_records AS rr " \ "WHERE DATE(rr.date_from) BETWEEN DATE(%s) AND DATE(%s) " \ "GROUP BY cplate ORDER BY RentAmount LIMIT %s" val = (start_first_month, end_third_month, limit) cursor.execute(sql, val) return cursor.fetchall(), [i[0] for i in cursor.description]
class MySQLConnector: def __init__(self): try: self.connection = MySQLConnection(**config) print("Connection created") self.cursor = self.connection.cursor(dictionary=True) except mysql.connector.Error as err: if err.errno == errorcode.ER_ACCESS_DENIED_ERROR: print("Something is wrong with your user name or password") elif err.errno == errorcode.ER_BAD_DB_ERROR: print("Database does not exist") else: print(err) def query(self, query, args=None): if args is None: self.cursor.execute(query) else: self.cursor.execute(query, args) def fetchone(self): return self.cursor.fetchone() def fetchall(self): return self.cursor.fetchall() def insert(self, query): self.query(query) self.connection.commit() def update(self, query, args): self.query(query, args) self.connection.commit() def delete(self, query): self.query(query) self.connection.commit() def close(self): self.cursor.close() self.connection.close() print("Connection closed")
def query6(conn: MySQLConnection): def preload_data(): pass # no need to preload data, use the sample data from the database preload_data() mor1 = time(7, 0) mor2 = time(10, 0) aft1 = time(12, 0) aft2 = time(14, 0) eve1 = time(17, 0) eve2 = time(19, 0) cursor = conn.cursor() sql = "SELECT COUNT(IF(TIME(date_from) BETWEEN TIME(%s) AND TIME(%s), 1, NULL)) AS MorningTravels," \ "COUNT(IF(TIME(date_from) BETWEEN TIME(%s) AND TIME(%s), 1, NULL)) AS AfternoonTravels," \ "COUNT(IF(TIME(date_from) BETWEEN TIME(%s) AND TIME(%s), 1, NULL)) AS EveningTravels " \ "FROM rent_records" value = (mor1, mor2, aft1, aft2, eve1, eve2) cursor.execute(sql, value) return cursor.fetchall(), [i[0] for i in cursor.description]
def insert_block(conn: MySQLConnection, block: Block, coin_type: str): c = conn.cursor() try: b = block with profiler.profile("sql: insert block"): c.execute( INSERT_BLOCK, (b.height, b.block_size, b.block_weight, b.difficulty, b.cumulative_difficulty, b.hash, b.long_term_weight, b.major_version, b.minor_version, b.nonce, b.reward, b.timestamp, b.wide_cumulative_difficulty, b.wide_difficulty)) bt = b.miner_tx with profiler.profile("insert cb transaction"): insert_transaction(c, bt, coin_type) # c.execute(INSERT_TRANSACTION, (bt.version, bt.hash_hex, bt.fee, bt.block_height, bt.unlock_time)) bt.tx_id = c.lastrowid for t in b.txs: # hash_value = int(t.hash_hex, 16) with profiler.profile("insert transaction"): insert_transaction(c, t, coin_type) # c.execute(INSERT_TRANSACTION, (t.version, t.hash_hex, t.fee, t.block_height, t.unlock_time)) # t.tx_id = c.lastrowid # print(f"inserted transaction, rows updated{c.rowcount}") # for tx_in in t.tx_ins: # c.execute(INSERT_TXIN, (t.tx_id, tx_in.amount, tx_in.key_image, tx_in.coinbase)) # tx_in.txin_id = c.lastrowid # for keyoffset in tx_in.key_offsets: # c.execute(INSERT_KEY_OFFSET, (tx_in.txin_id, keyoffset)) # for od in tx_in.out_details: # od.tx_id = t.tx_id # c.execute(INSERT_OUTPUT_DETAILS, (od.tx_id, od.height, od.key_hex, od.mask_hex, od.unlocked)) # for tx_out in t.tx_outs: # c.execute(INSERT_TXOUT, (t.tx_id, tx_out.amount, tx_out.target_key)) conn.commit() c.close() except Exception as e: logger.exception(f"ERROR AT HEIGHT:{block.height}" ) #should automatically dump the stack conn.rollback() c.close()
class SqlConnector: def __init__(self, schema_name): self.schema_name = schema_name self.cnx = None self.error_log = [] def __enter__(self, schema_name): try: self.cnx = MySQLConnection(**config_local) except: self.cnx = MySQLConnection(**config_remote) self.cnx.database = schema_name print("Successfully opened MySQLConnection") def __exit__(self): if self.cnx is not None: self.cnx.close() print("Successfully closed MySQLConnection") def execute_in_cursor(self, command): new_cursor = self.cnx.cursor() try: new_cursor.execute(command) result = list(new_cursor) new_cursor.close() print(f"Query results for ( {command} ): {result}") return result except Exception as e: print(f"Query error occured: {e}") self.error_log += [(command, e)] finally: new_cursor.close() def print_error_log(self): if not self.error_log: return print("No errors logged.\nDatabase update successful!") print("Errors logged:") for error in self.error_log: print(error) print("Database update unsuccessful!")
def query5(conn: MySQLConnection): cursor = conn.cursor() date = datetime(2018, 11, 27, 0, 0, 0) def preload_data(): sql = "SELECT * FROM customers LIMIT 100" cursor.execute(sql) ids = [x[0] for x in cursor.fetchall()] sql = "SELECT * FROM cars LIMIT 50" cursor.execute(sql) plates = [x[0] for x in cursor.fetchall()] # remove all rent records on the date loaded by sample data sql = "DELETE FROM rent_records WHERE DATE(date_from) = DATE(%s)" cursor.execute(sql, (date, )) conn.commit() # insert random rent records on the date with random pairs of customers and cars for i in range(100): sql = "INSERT INTO rent_records (date_from, date_to, cid, cplate, distance) " \ "VALUES (%s, %s, %s, %s, %s)" date_from = get_fake_date_time(start=date, end=date + timedelta(days=1)) date_to = get_fake_date_time(start=date_from, end=date + timedelta(days=1)) val = (date_from, date_to, choice(ids), choice(plates), randint(1, 100)) cursor.execute(sql, val) conn.commit() preload_data() query = "SELECT AVG(MINUTE(TIMEDIFF(date_from, date_to))) AS AvgTripDurationInMinutes " \ "FROM rent_records WHERE DATE(date_from) = %s" value = (date, ) cursor.execute(query, value) return cursor.fetchall(), [i[0] for i in cursor.description]
def abre_cursor(con: MySQLConnection, log: bool = False) -> Union[CursorBase, int]: """Cria o cursor para executar queries sql. Args: con (MySQLConnection): Uma conexão com um banco de previamente aberta. log (bool, optional): Ativa e desativa o logging. Default é False. Returns: Union[CursorBase, int]: O cursor aberto com buffer ativado caso tenha dado certo ou -1 caso alguma coisa tenha dado errado ao abrir o cursor. """ try: # if con is None or not con.is_connected(): # con = conecta_servidor() cursor = con.cursor(buffered=True) if log: print("Cursor aberto.") return cursor except Exception as e: if log: print("Cursor não foi aberto", e) return 0
class TestsCursor(TestsDataTypes): def setUp(self): config = self.getMySQLConfig() self.db = MySQLConnection(**config) c = self.db.cursor() tblNames = self.tables.values() c.execute("DROP TABLE IF EXISTS %s" % (",".join(tblNames))) c.close() def tearDown(self): c = self.db.cursor() tblNames = self.tables.values() c.execute("DROP TABLE IF EXISTS %s" % (",".join(tblNames))) c.close() self.db.close() def test_numeric_int(self): """MySQL numeric integer data types""" c = self.db.cursor() columns = [ "tinyint_signed", "tinyint_unsigned", "bool_signed", "smallint_signed", "smallint_unsigned", "mediumint_signed", "mediumint_unsigned", "int_signed", "int_unsigned", "bigint_signed", "bigint_unsigned", ] c.execute( """CREATE TABLE %s ( `id` TINYINT UNSIGNED NOT NULL AUTO_INCREMENT, `tinyint_signed` TINYINT SIGNED, `tinyint_unsigned` TINYINT UNSIGNED, `bool_signed` BOOL, `smallint_signed` SMALLINT SIGNED, `smallint_unsigned` SMALLINT UNSIGNED, `mediumint_signed` MEDIUMINT SIGNED, `mediumint_unsigned` MEDIUMINT UNSIGNED, `int_signed` INT SIGNED, `int_unsigned` INT UNSIGNED, `bigint_signed` BIGINT SIGNED, `bigint_unsigned` BIGINT UNSIGNED, PRIMARY KEY (id) ) """ % (self.tables["int"]) ) data = [ ( -128, # tinyint signed 0, # tinyint unsigned 0, # boolean -32768, # smallint signed 0, # smallint unsigned -8388608, # mediumint signed 0, # mediumint unsigned -2147483648, # int signed 0, # int unsigned -9223372036854775808, # big signed 0, # big unsigned ), ( 127, # tinyint signed 255, # tinyint unsigned 127, # boolean 32767, # smallint signed 65535, # smallint unsigned 8388607, # mediumint signed 16777215, # mediumint unsigned 2147483647, # int signed 4294967295, # int unsigned 9223372036854775807, # big signed 18446744073709551615, # big unsigned ), ] insert = self._get_insert_stmt(self.tables["int"], columns) select = self._get_select_stmt(self.tables["int"], columns) c.executemany(insert, data) c.execute(select) rows = c.fetchall() def compare(name, d, r): self.assertEqual(d, r, "%s %s != %s" % (name, d, r)) for i, col in enumerate(columns): compare(col, data[0][i], rows[0][i]) compare(col, data[1][i], rows[1][i]) c.close() def test_numeric_bit(self): """MySQL numeric bit data type""" c = self.db.cursor() columns = ["c8", "c16", "c24", "c32", "c40", "c48", "c56", "c63", "c64"] c.execute( """CREATE TABLE %s ( `id` int NOT NULL AUTO_INCREMENT, `c8` bit(8) DEFAULT NULL, `c16` bit(16) DEFAULT NULL, `c24` bit(24) DEFAULT NULL, `c32` bit(32) DEFAULT NULL, `c40` bit(40) DEFAULT NULL, `c48` bit(48) DEFAULT NULL, `c56` bit(56) DEFAULT NULL, `c63` bit(63) DEFAULT NULL, `c64` bit(64) DEFAULT NULL, PRIMARY KEY (id) ) """ % self.tables["bit"] ) insert = self._get_insert_stmt(self.tables["bit"], columns) select = self._get_select_stmt(self.tables["bit"], columns) data = list() data.append(tuple([0] * len(columns))) values = list() for col in columns: values.append(1 << int(col.replace("c", "")) - 1) data.append(tuple(values)) values = list() for col in columns: values.append((1 << int(col.replace("c", ""))) - 1) data.append(tuple(values)) c.executemany(insert, data) c.execute(select) rows = c.fetchall() self.assertEqual(rows, data) c.close() def test_numeric_float(self): """MySQL numeric float data type""" c = self.db.cursor() columns = ["float_signed", "float_unsigned", "double_signed", "double_unsigned"] c.execute( """CREATE TABLE %s ( `id` int NOT NULL AUTO_INCREMENT, `float_signed` FLOAT(6,5) SIGNED, `float_unsigned` FLOAT(6,5) UNSIGNED, `double_signed` DOUBLE(15,10) SIGNED, `double_unsigned` DOUBLE(15,10) UNSIGNED, PRIMARY KEY (id) )""" % (self.tables["float"]) ) insert = self._get_insert_stmt(self.tables["float"], columns) select = self._get_select_stmt(self.tables["float"], columns) data = [ (-3.402823466, 0, -1.7976931348623157, 0), (-1.175494351, 3.402823466, 1.7976931348623157, 2.2250738585072014), (-1.23455678, 2.999999, -1.3999999999999999, 1.9999999999999999), ] c.executemany(insert, data) c.execute(select) rows = c.fetchall() def compare(name, d, r): self.assertEqual(d, r, "%s %s != %s" % (name, d, r)) for j in range(0, len(data)): for i, col in enumerate(columns[0:2]): compare(col, round(data[j][i], 5), rows[j][i]) for i, col in enumerate(columns[2:2]): compare(col, round(data[j][i], 10), rows[j][i]) c.close() def test_numeric_decimal(self): """MySQL numeric decimal data type""" c = self.db.cursor() columns = ["decimal_signed", "decimal_unsigned"] c.execute( """CREATE TABLE %s ( `id` int NOT NULL AUTO_INCREMENT, `decimal_signed` DECIMAL(65,30) SIGNED, `decimal_unsigned` DECIMAL(65,30) UNSIGNED, PRIMARY KEY (id) )""" % (self.tables["decimal"]) ) insert = self._get_insert_stmt(self.tables["decimal"], columns) select = self._get_select_stmt(self.tables["decimal"], columns) data = [ ( Decimal("-9999999999999999999999999.999999999999999999999999999999"), Decimal("+9999999999999999999999999.999999999999999999999999999999"), ), (Decimal("-1234567.1234"), Decimal("+123456789012345.123456789012345678901")), ( Decimal("-1234567890123456789012345.123456789012345678901234567890"), Decimal("+1234567890123456789012345.123456789012345678901234567890"), ), ] c.executemany(insert, data) c.execute(select) rows = c.fetchall() self.assertEqual(data, rows) c.close() def test_temporal_datetime(self): """MySQL temporal date/time data types""" c = self.db.cursor() c.execute("SET SESSION time_zone = '+00:00'") columns = ["t_date", "t_datetime", "t_time", "t_timestamp", "t_year_2", "t_year_4"] c.execute( """CREATE TABLE %s ( `id` int NOT NULL AUTO_INCREMENT, `t_date` DATE, `t_datetime` DATETIME, `t_time` TIME, `t_timestamp` TIMESTAMP DEFAULT 0, `t_year_2` YEAR(2), `t_year_4` YEAR(4), PRIMARY KEY (id) )""" % (self.tables["temporal"]) ) insert = self._get_insert_stmt(self.tables["temporal"], columns) select = self._get_select_stmt(self.tables["temporal"], columns) data = [ ( datetime.date(2010, 1, 17), datetime.datetime(2010, 1, 17, 19, 31, 12), datetime.timedelta(hours=43, minutes=32, seconds=21), datetime.datetime(2010, 1, 17, 19, 31, 12), 10, 0, ), ( datetime.date(1000, 1, 1), datetime.datetime(1000, 1, 1, 0, 0, 0), datetime.timedelta(hours=-838, minutes=59, seconds=59), datetime.datetime(*time.gmtime(1)[:6]), 70, 1901, ), ( datetime.date(9999, 12, 31), datetime.datetime(9999, 12, 31, 23, 59, 59), datetime.timedelta(hours=838, minutes=59, seconds=59), datetime.datetime(2038, 1, 19, 3, 14, 7), 69, 2155, ), ] c.executemany(insert, data) c.execute(select) rows = c.fetchall() from pprint import pprint def compare(name, d, r): self.assertEqual(d, r, "%s %s != %s" % (name, d, r)) for j in range(0, len(data)): for i, col in enumerate(columns): compare("%s (data[%d])" % (col, j), data[j][i], rows[j][i]) c.close()
def build_cursor(self, connection: MySQLConnection) -> MySQLCursor: return connection.cursor()
class MySqlDB: def __init__(self, settings): self.settings = dict(**settings) self.connection = None def init_connection(self): if self.connection is None: self.connection = MySQLConnection( host = self.settings.get('DB_HOST', '127.0.0.1'), port = self.settings.get('DB_PORT', 3306), user = self.settings.get('DB_USER', 'root'), password = self.settings.get('DB_PASSWORD', ''), database = self.settings.get('DB_NAME', 'mysql'), ) def is_connected(self): if self.connection is None: self.init_connection() return self.connection.is_connected() def reconnect(self, attempts, delay): if self.connection is None: self.init_connection() return self.connection.reconnect() def rollback(self): if self.connection is None: self.init_connection() self.connection.rollback() def commit(self): if self.connection is None: self.init_connection() self.connection.commit() @contextlib.contextmanager def cursor(self, buffered=True, rollback_on_error=True, **kwargs): if self.connection is None: self.init_connection() cursor = None try: kwargs = kwargs or {} kwargs.setdefault("dictionary", True) kwargs.setdefault("buffered", buffered) cursor = self.connection.cursor(**kwargs) yield cursor except MySqlError as error: if rollback_on_error: self.connection.rollback() raise error from None finally: if cursor: cursor.close() def fetchone(self, query, params=None, **kwargs): if self.connection is None: self.init_connection() cursor = None try: kwargs = kwargs or {"dictionary": True} kwargs.setdefault("buffered", True) cursor = self.connection.cursor(**kwargs) cursor.execute(query, params) result = cursor.fetchone() return result finally: if cursor: cursor.close() def fetchall(self, query, params=None, **kwargs): if self.connection is None: self.init_connection() cursor = None try: kwargs = kwargs or {"dictionary": True} kwargs.setdefault("buffered", True) cursor = self.connection.cursor(**kwargs) cursor.execute(query, params) result = cursor.fetchall() return result finally: if cursor: cursor.close() def close(self): if self.connection is not None: self.connection.close()
class TestsCursor(TestsDataTypes): def setUp(self): config = self.getMySQLConfig() self.db = MySQLConnection(**config) c = self.db.cursor() tblNames = self.tables.values() c.execute("DROP TABLE IF EXISTS %s" % (','.join(tblNames))) c.close() def tearDown(self): c = self.db.cursor() tblNames = self.tables.values() c.execute("DROP TABLE IF EXISTS %s" % (','.join(tblNames))) c.close() self.db.close() def test_numeric_int(self): """MySQL numeric integer data types""" c = self.db.cursor() columns = [ 'tinyint_signed', 'tinyint_unsigned', 'bool_signed', 'smallint_signed', 'smallint_unsigned', 'mediumint_signed', 'mediumint_unsigned', 'int_signed', 'int_unsigned', 'bigint_signed', 'bigint_unsigned', ] c.execute("""CREATE TABLE %s ( `id` TINYINT UNSIGNED NOT NULL AUTO_INCREMENT, `tinyint_signed` TINYINT SIGNED, `tinyint_unsigned` TINYINT UNSIGNED, `bool_signed` BOOL, `smallint_signed` SMALLINT SIGNED, `smallint_unsigned` SMALLINT UNSIGNED, `mediumint_signed` MEDIUMINT SIGNED, `mediumint_unsigned` MEDIUMINT UNSIGNED, `int_signed` INT SIGNED, `int_unsigned` INT UNSIGNED, `bigint_signed` BIGINT SIGNED, `bigint_unsigned` BIGINT UNSIGNED, PRIMARY KEY (id) ) """ % (self.tables['int'])) data = [ ( -128, # tinyint signed 0, # tinyint unsigned 0, # boolean -32768, # smallint signed 0, # smallint unsigned -8388608, # mediumint signed 0, # mediumint unsigned -2147483648, # int signed 0, # int unsigned -9223372036854775808, # big signed 0, # big unsigned ), ( 127, # tinyint signed 255, # tinyint unsigned 127, # boolean 32767, # smallint signed 65535, # smallint unsigned 8388607, # mediumint signed 16777215, # mediumint unsigned 2147483647, # int signed 4294967295, # int unsigned 9223372036854775807, # big signed 18446744073709551615, # big unsigned ) ] insert = self._get_insert_stmt(self.tables['int'], columns) select = self._get_select_stmt(self.tables['int'], columns) c.executemany(insert, data) c.execute(select) rows = c.fetchall() def compare(name, d, r): self.assertEqual(d, r, "%s %s != %s" % (name, d, r)) for i, col in enumerate(columns): compare(col, data[0][i], rows[0][i]) compare(col, data[1][i], rows[1][i]) c.close() def test_numeric_bit(self): """MySQL numeric bit data type""" c = self.db.cursor() columns = [ 'c8', 'c16', 'c24', 'c32', 'c40', 'c48', 'c56', 'c63', 'c64' ] c.execute("""CREATE TABLE %s ( `id` int NOT NULL AUTO_INCREMENT, `c8` bit(8) DEFAULT NULL, `c16` bit(16) DEFAULT NULL, `c24` bit(24) DEFAULT NULL, `c32` bit(32) DEFAULT NULL, `c40` bit(40) DEFAULT NULL, `c48` bit(48) DEFAULT NULL, `c56` bit(56) DEFAULT NULL, `c63` bit(63) DEFAULT NULL, `c64` bit(64) DEFAULT NULL, PRIMARY KEY (id) ) """ % self.tables['bit']) insert = self._get_insert_stmt(self.tables['bit'], columns) select = self._get_select_stmt(self.tables['bit'], columns) data = list() data.append(tuple([0] * len(columns))) values = list() for col in columns: values.append(1 << int(col.replace('c', '')) - 1) data.append(tuple(values)) values = list() for col in columns: values.append((1 << int(col.replace('c', ''))) - 1) data.append(tuple(values)) c.executemany(insert, data) c.execute(select) rows = c.fetchall() self.assertEqual(rows, data) c.close() def test_numeric_float(self): """MySQL numeric float data type""" c = self.db.cursor() columns = [ 'float_signed', 'float_unsigned', 'double_signed', 'double_unsigned', ] c.execute("""CREATE TABLE %s ( `id` int NOT NULL AUTO_INCREMENT, `float_signed` FLOAT(6,5) SIGNED, `float_unsigned` FLOAT(6,5) UNSIGNED, `double_signed` DOUBLE(15,10) SIGNED, `double_unsigned` DOUBLE(15,10) UNSIGNED, PRIMARY KEY (id) )""" % (self.tables['float'])) insert = self._get_insert_stmt(self.tables['float'], columns) select = self._get_select_stmt(self.tables['float'], columns) data = [ ( -3.402823466, 0, -1.7976931348623157, 0, ), (-1.175494351, 3.402823466, 1.7976931348623157, 2.2250738585072014), (-1.23455678, 2.999999, -1.3999999999999999, 1.9999999999999999), ] c.executemany(insert, data) c.execute(select) rows = c.fetchall() def compare(name, d, r): self.assertEqual(d, r, "%s %s != %s" % (name, d, r)) for j in (range(0, len(data))): for i, col in enumerate(columns[0:2]): compare(col, round(data[j][i], 5), rows[j][i]) for i, col in enumerate(columns[2:2]): compare(col, round(data[j][i], 10), rows[j][i]) c.close() def test_numeric_decimal(self): """MySQL numeric decimal data type""" c = self.db.cursor() columns = [ 'decimal_signed', 'decimal_unsigned', ] c.execute("""CREATE TABLE %s ( `id` int NOT NULL AUTO_INCREMENT, `decimal_signed` DECIMAL(65,30) SIGNED, `decimal_unsigned` DECIMAL(65,30) UNSIGNED, PRIMARY KEY (id) )""" % (self.tables['decimal'])) insert = self._get_insert_stmt(self.tables['decimal'], columns) select = self._get_select_stmt(self.tables['decimal'], columns) data = [ (Decimal( '-9999999999999999999999999.999999999999999999999999999999'), Decimal( '+9999999999999999999999999.999999999999999999999999999999')), (Decimal('-1234567.1234'), Decimal('+123456789012345.123456789012345678901')), (Decimal( '-1234567890123456789012345.123456789012345678901234567890'), Decimal( '+1234567890123456789012345.123456789012345678901234567890')), ] c.executemany(insert, data) c.execute(select) rows = c.fetchall() self.assertEqual(data, rows) c.close() def test_temporal_datetime(self): """MySQL temporal date/time data types""" c = self.db.cursor() c.execute("SET SESSION time_zone = '+00:00'") columns = [ 't_date', 't_datetime', 't_time', 't_timestamp', 't_year_4', ] c.execute("""CREATE TABLE %s ( `id` int NOT NULL AUTO_INCREMENT, `t_date` DATE, `t_datetime` DATETIME, `t_time` TIME, `t_timestamp` TIMESTAMP DEFAULT 0, `t_year_4` YEAR(4), PRIMARY KEY (id) )""" % (self.tables['temporal'])) insert = self._get_insert_stmt(self.tables['temporal'], columns) select = self._get_select_stmt(self.tables['temporal'], columns) data = [ (datetime.date(2010, 1, 17), datetime.datetime(2010, 1, 17, 19, 31, 12), datetime.timedelta(hours=43, minutes=32, seconds=21), datetime.datetime(2010, 1, 17, 19, 31, 12), 0), (datetime.date(1000, 1, 1), datetime.datetime(1000, 1, 1, 0, 0, 0), datetime.timedelta(hours=-838, minutes=59, seconds=59), datetime.datetime(*time.gmtime(1)[:6]), 1901), (datetime.date(9999, 12, 31), datetime.datetime(9999, 12, 31, 23, 59, 59), datetime.timedelta(hours=838, minutes=59, seconds=59), datetime.datetime(2038, 1, 19, 3, 14, 7), 2155), ] c.executemany(insert, data) c.execute(select) rows = c.fetchall() def compare(name, d, r): self.assertEqual(d, r, "%s %s != %s" % (name, d, r)) for j in (range(0, len(data))): for i, col in enumerate(columns): compare("%s (data[%d])" % (col, j), data[j][i], rows[j][i]) # Testing YEAR(2), which is now obsolete since MySQL 5.6.6 tblname = self.tables['temporal_year'] c.execute("CREATE TABLE %s (" "`id` int NOT NULL AUTO_INCREMENT KEY, " "`t_year_2` YEAR(2))" % tblname) c.execute(self._get_insert_stmt(tblname, ['t_year_2']), (10, )) c.execute(self._get_select_stmt(tblname, ['t_year_2'])) row = c.fetchone() if tests.MYSQL_VERSION >= (5, 6, 6): self.assertEqual(2010, row[0]) else: self.assertEqual(10, row[0]) c.close()
class TestsCursor(TestsDataTypes): def setUp(self): config = self.getMySQLConfig() self.db = MySQLConnection(**config) c = self.db.cursor() tblNames = self.tables.values() c.execute("DROP TABLE IF EXISTS %s" % (','.join(tblNames))) c.close() def tearDown(self): c = self.db.cursor() tblNames = self.tables.values() c.execute("DROP TABLE IF EXISTS %s" % (','.join(tblNames))) c.close() self.db.close() def test_numeric_int(self): """MySQL numeric integer data types""" c = self.db.cursor() columns = [ 'tinyint_signed', 'tinyint_unsigned', 'bool_signed', 'smallint_signed', 'smallint_unsigned', 'mediumint_signed', 'mediumint_unsigned', 'int_signed', 'int_unsigned', 'bigint_signed', 'bigint_unsigned', ] c.execute("""CREATE TABLE %s ( `id` TINYINT UNSIGNED NOT NULL AUTO_INCREMENT, `tinyint_signed` TINYINT SIGNED, `tinyint_unsigned` TINYINT UNSIGNED, `bool_signed` BOOL, `smallint_signed` SMALLINT SIGNED, `smallint_unsigned` SMALLINT UNSIGNED, `mediumint_signed` MEDIUMINT SIGNED, `mediumint_unsigned` MEDIUMINT UNSIGNED, `int_signed` INT SIGNED, `int_unsigned` INT UNSIGNED, `bigint_signed` BIGINT SIGNED, `bigint_unsigned` BIGINT UNSIGNED, PRIMARY KEY (id) ) """ % (self.tables['int'])) data = [ ( -128, # tinyint signed 0, # tinyint unsigned 0, # boolean -32768, # smallint signed 0, # smallint unsigned -8388608, # mediumint signed 0, # mediumint unsigned -2147483648, # int signed 0, # int unsigned -9223372036854775808, # big signed 0, # big unsigned ), ( 127, # tinyint signed 255, # tinyint unsigned 127, # boolean 32767, # smallint signed 65535, # smallint unsigned 8388607, # mediumint signed 16777215, # mediumint unsigned 2147483647, # int signed 4294967295, # int unsigned 9223372036854775807, # big signed 18446744073709551615, # big unsigned ) ] insert = self._get_insert_stmt(self.tables['int'],columns) select = self._get_select_stmt(self.tables['int'],columns) c.executemany(insert, data) c.execute(select) rows = c.fetchall() def compare(name, d, r): self.assertEqual(d,r,"%s %s != %s" % (name,d,r)) for i,col in enumerate(columns): compare(col,data[0][i],rows[0][i]) compare(col,data[1][i],rows[1][i]) c.close() def test_numeric_bit(self): """MySQL numeric bit data type""" c = self.db.cursor() columns = [ 'c8','c16','c24','c32', 'c40','c48','c56','c63', 'c64'] c.execute("""CREATE TABLE %s ( `id` int NOT NULL AUTO_INCREMENT, `c8` bit(8) DEFAULT NULL, `c16` bit(16) DEFAULT NULL, `c24` bit(24) DEFAULT NULL, `c32` bit(32) DEFAULT NULL, `c40` bit(40) DEFAULT NULL, `c48` bit(48) DEFAULT NULL, `c56` bit(56) DEFAULT NULL, `c63` bit(63) DEFAULT NULL, `c64` bit(64) DEFAULT NULL, PRIMARY KEY (id) ) """ % self.tables['bit']) insert = self._get_insert_stmt(self.tables['bit'],columns) select = self._get_select_stmt(self.tables['bit'],columns) data = list() data.append(tuple([0]*len(columns))) values = list() for col in columns: values.append( 1 << int(col.replace('c',''))-1) data.append(tuple(values)) values = list() for col in columns: values.append( (1 << int(col.replace('c',''))) -1) data.append(tuple(values)) c.executemany(insert, data) c.execute(select) rows = c.fetchall() self.assertEqual(rows, data) c.close() def test_numeric_float(self): """MySQL numeric float data type""" c = self.db.cursor() columns = [ 'float_signed', 'float_unsigned', 'double_signed', 'double_unsigned', ] c.execute("""CREATE TABLE %s ( `id` int NOT NULL AUTO_INCREMENT, `float_signed` FLOAT(6,5) SIGNED, `float_unsigned` FLOAT(6,5) UNSIGNED, `double_signed` DOUBLE(15,10) SIGNED, `double_unsigned` DOUBLE(15,10) UNSIGNED, PRIMARY KEY (id) )""" % (self.tables['float'])) insert = self._get_insert_stmt(self.tables['float'],columns) select = self._get_select_stmt(self.tables['float'],columns) data = [ (-3.402823466,0,-1.7976931348623157,0,), (-1.175494351,3.402823466,1.7976931348623157,2.2250738585072014), (-1.23455678,2.999999,-1.3999999999999999,1.9999999999999999), ] c.executemany(insert, data) c.execute(select) rows = c.fetchall() def compare(name, d, r): self.assertEqual(d,r,"%s %s != %s" % (name,d,r)) for j in (range(0,len(data))): for i,col in enumerate(columns[0:2]): compare(col,round(data[j][i],5),rows[j][i]) for i,col in enumerate(columns[2:2]): compare(col,round(data[j][i],10),rows[j][i]) c.close() def test_numeric_decimal(self): """MySQL numeric decimal data type""" c = self.db.cursor() columns = [ 'decimal_signed', 'decimal_unsigned', ] c.execute("""CREATE TABLE %s ( `id` int NOT NULL AUTO_INCREMENT, `decimal_signed` DECIMAL(65,30) SIGNED, `decimal_unsigned` DECIMAL(65,30) UNSIGNED, PRIMARY KEY (id) )""" % (self.tables['decimal'])) insert = self._get_insert_stmt(self.tables['decimal'],columns) select = self._get_select_stmt(self.tables['decimal'],columns) data = [ (Decimal('-9999999999999999999999999.999999999999999999999999999999'), Decimal('+9999999999999999999999999.999999999999999999999999999999')), (Decimal('-1234567.1234'), Decimal('+123456789012345.123456789012345678901')), (Decimal('-1234567890123456789012345.123456789012345678901234567890'), Decimal('+1234567890123456789012345.123456789012345678901234567890')), ] c.executemany(insert, data) c.execute(select) rows = c.fetchall() self.assertEqual(data,rows) c.close() def test_temporal_datetime(self): """MySQL temporal date/time data types""" c = self.db.cursor() c.execute("SET SESSION time_zone = '+00:00'") columns = [ 't_date', 't_datetime', 't_time', 't_timestamp', 't_year_4', ] c.execute("""CREATE TABLE %s ( `id` int NOT NULL AUTO_INCREMENT, `t_date` DATE, `t_datetime` DATETIME, `t_time` TIME, `t_timestamp` TIMESTAMP DEFAULT 0, `t_year_4` YEAR(4), PRIMARY KEY (id) )""" % (self.tables['temporal'])) insert = self._get_insert_stmt(self.tables['temporal'],columns) select = self._get_select_stmt(self.tables['temporal'],columns) data = [ (datetime.date(2010,1,17), datetime.datetime(2010,1,17,19,31,12), datetime.timedelta(hours=43,minutes=32,seconds=21), datetime.datetime(2010,1,17,19,31,12), 0), (datetime.date(1000,1,1), datetime.datetime(1000,1,1,0,0,0), datetime.timedelta(hours=-838,minutes=59,seconds=59), datetime.datetime(*time.gmtime(1)[:6]), 1901), (datetime.date(9999,12,31), datetime.datetime(9999,12,31,23,59,59), datetime.timedelta(hours=838,minutes=59,seconds=59), datetime.datetime(2038,1,19,3,14,7), 2155), ] c.executemany(insert, data) c.execute(select) rows = c.fetchall() def compare(name, d, r): self.assertEqual(d,r,"%s %s != %s" % (name,d,r)) for j in (range(0,len(data))): for i,col in enumerate(columns): compare("%s (data[%d])" % (col,j),data[j][i],rows[j][i]) # Testing YEAR(2), which is now obsolete since MySQL 5.6.6 tblname = self.tables['temporal_year'] c.execute("CREATE TABLE %s (" "`id` int NOT NULL AUTO_INCREMENT KEY, " "`t_year_2` YEAR(2))" % tblname) c.execute(self._get_insert_stmt(tblname, ['t_year_2']), (10,)) c.execute(self._get_select_stmt(tblname, ['t_year_2'])) row = c.fetchone() if tests.MYSQL_VERSION >= (5, 6, 6): self.assertEqual(2010, row[0]) else: self.assertEqual(10, row[0]) c.close()
class ParseXML(object): def __init__(self, file): self.cnx = MySQLConnection() self.local_cursor = MySQLCursor() self.external_db_cnx = MySQLConnection() self.file = file self.xml = etree.parse(file).getroot() self.dict = self.xml[1] #self.truncate() #self.generate_model() def connect_to_db(self): self.cnx = connect(user='******', password ='******', host='127.0.0.1', database='combinatoria') #database='test') self.local_cursor = self.cnx.cursor() def generate_model(self): project = models.Project() project.save() script = models.Script() info_node = self.xml[0] script.author = info_node[0].text script.title = info_node[1].text script.description = info_node[2].text script.date = date(year=2007, month=7, day=1) script.save() project.script_set.add(script) act = models.Act() act.title = 'conversations' act.script = script act.save() scenes = self.xml.findall('conversation') for scene in scenes: scene_model = models.Scene() scene_model.title = self.dict_value(scene.attrib['title']) scene_model.description scene_model.act = act scene_model.save() parts = scene.findall('section') for part in parts: part_model = models.Part() part_model.scene = scene_model part_model.name = self.dict_value(part.attrib['keyword']) part_model.description = part.attrib['summary'] part_model.save() contents = part.findall('cut') for cut in contents: content_model = models.Content() content_model.part = part_model content_model.save() part_model.content_set.add(content_model) self.content_factory(content_model, cut) pass def content_factory(self, content, cut): type = cut.attrib['type'] if(type == 'pause'): self.process_pause(content, cut) elif(type == 'default'): self.process_default(content, cut) elif(type == 'alternative'): self.process_alternative(content, cut) def process_pause(self, content, cut): scene_name = self.get_scene_name(content.part_id) scene_code = self.dict_key(scene_name) part_name = models.Part.objects.get(pk=content.part_id).name part_code = self.dict_key(part_name) pause = models.Group() pause.content_id = content.id pause.name = scene_code + '_' + part_code + '_' + 'pause' pause.save() type = models.Type() type.name = 'SEQUENCE_SET' params = [{'sets':['short', 'medium', 'long']}] type.arguments = json.dumps(params) type.group_id = pause.id type.content_id = content.id pause.type_set.add(type) pause_txt = models.Line() pause_txt.line = 'pause' pause_txt.save() content.line_set.add(pause_txt) pause.line.add(pause_txt) library = models.Group() library.name = 'library' library.content_id = content.id library.save() pause_library = models.GroupContainer(container=pause, group=library) pause_library.save() angles = cut.findall("./shots/angle") for angle in angles: source = models.Source() source.file = scene_code + '_' + part_code + '_' + angle.attrib['type'] + '.mp4' source.mime = 'video/mp4' source.duration = float(angle.attrib['length']) * 1000 source.size = int(angle.attrib['bytes']) source.save() library_source = models.GroupSource(group=library, source=source, order=0) library_source.save() sets = models.Group() sets.name = 'sets' sets.content_id = content.id sets.save() short = models.Group() short.name = 'short' short.content_id = content.id short.save() set_short = models.GroupContainer(container=sets, group=short, has_group=True) set_short.save() short_seq_str = cut.find('./sequence[@type="short"]').text short_seq = short_seq_str.split(',') sequences = [re.split('[+]', items) for items in short_seq] i = 0 for seq in sequences: for items in seq: items = items.split(',') group = models.Group() i += 1 group.name = 'short_' + str(i) group.content_id = content.id group.save() counter = 0 for item in items: counter += 1 source = models.Source.objects.get(file=scene_code + '_' + part_code + '_' + item + '.mp4') group_source = models.GroupSource(group=group, source=source, order=counter) group_source.save() short_group = models.GroupContainer(container=short, group=group) short_group.save() medium = models.Group() medium.name = 'medium' medium.content_id = content.id medium.save() sets_medium = models.GroupContainer(container=sets, group=medium, has_group=True) sets_medium.save() med_seq_str = cut.find('./sequence[@type="medium"]').text med_seq = med_seq_str.split(',') sequences = [re.split('[+]', items) for items in med_seq] i = 0 for seq in sequences: group = models.Group() i += 1 group.name = 'medium_' + str(i) group.content_id = content.id group.save() counter = 0 for item in seq: counter += 1 source = models.Source.objects.get(file=scene_code + '_' + part_code + '_' + item + '.mp4') group_source = models.GroupSource(group=group, source=source, order=counter) group_source.save() #source.group_set.add(group) medium_group = models.GroupContainer(container=medium, group=group) medium_group.save() #medium.group_set.add(group) #long = models.Item() long = models.Group() long.name = 'long' long.content_id = content.id long.save() #sets.item.add(long) sets_long = models.GroupContainer(container=sets, group=long, has_group=True) sets_long.save() long_seq_str = cut.find('./sequence[@type="long"]').text long_seq = long_seq_str.split(',') sequences = [re.split('[+]', items) for items in long_seq] i = 0 for seq in sequences: group = models.Group() i += 1 group.name = 'long_' + str(i) group.content_id = content.id group._deferred = False group.save() long_group = models.GroupContainer(container=long, group=group) long_group.save() #long.group_set.add(group) counter = 0 for item in seq: counter += 1 source = models.Source.objects.get(file=scene_code + '_' + part_code + '_' + item + '.mp4') group_source = models.GroupSource(group=group, source=source, order=counter) group_source.save() #source.group_set.add(group) group.save() pause.save() content.group_set.add(pause) return 0 def process_default(self, content, cut): default = models.Line() default.line = cut.find('line').text default.speaker = cut.attrib['speaker'] default.save() content.line_set.add(default) default_type = models.Type() default_type.name = 'DEFAULT' default_type.content_id = content.id default_type.save() default.type_set.add(default_type) shots = cut.findall('./shots/angle') for shot in shots: source = models.Source() source.file = cut.find('name').text + '_' + shot.attrib['type'] + '.mp4' source.duration = float(shot.attrib['length']) * 1000 source.mime = 'video/mp4' source.size = shot.attrib['bytes'] source.save() line_source = models.LineSource(source=source, line=default) line_source.save() #default.source.add(source) def process_alternative(self, content, cut): alternative = self.init_alternative(content, cut) alt_type = alternative.type_set.get().name print(alt_type) if alt_type == 'ALTERNATIVE_FREE': self.process_options(content, alternative, cut) if alt_type == 'ALTERNATIVE_PAIRED': self.process_options(content, alternative, cut) if alt_type == 'ALTERNATIVE_PARENT': alts = cut.findall('./alternative') parent = models.Group.objects.last()#(content_id=content.id) #parent.name = 'alternative_parent' #parent.save() counter = 0 for alt in alts: counter += 1 alt.attrib['speaker'] = cut.attrib['speaker'] self.process_alternative(content, alt) child = models.Group.objects.last() parent_child = models.GroupContainer(container=parent, group=child, order=counter) parent_child.save() if alt_type == 'ALTERNATIVE_PAIRED_PARENT': alts = cut.findall('./alternative') parent = models.Group.objects.last() #(content_id=content.id) #parent.name = 'alternative_paired_parent' #parent.save() counter = 0 for alt in alts: counter += 1 alt.attrib['speaker'] = cut.attrib['speaker'] self.process_alternative(content, alt) child = models.Group.objects.last() parent_child = models.GroupContainer(container=parent, group=child, order=counter) parent_child.save() if alt_type == 'ALTERNATIVE_COMPOUND': default = self.write_line(content.id, cut.attrib['speaker'], cut.find('./default/line').text) content.line_set.add(default) # default_type = models.Type() # default_type.name = 'DEFAULT' # default_type.content_id = content.id # default_type.save() # default.type_set.add(default_type) shots = cut.findall('./default/shots/angle') for shot in shots: source = models.Source() source.file = cut.find('./default/name').text + '_' + shot.attrib['type'] + '.mp4' source.duration = float(shot.attrib['length']) * 1000 source.mime = 'video/mp4' source.size = shot.attrib['bytes'] source.save() line_source = models.LineSource(source=source, line=default) line_source.save() alternative.line.add(default) self.process_options(content, alternative, cut) if alt_type == 'ALTERNATIVE_PAIRED_MIXED': nested = cut.findall('./nested') nested[0].attrib['speaker'] = cut.attrib['speaker'] self.init_alternative(content, nested[0]) return def init_alternative(self, content, cut): alternative = models.Group() alternative.save() type = self.write_alt_type(cut) content.type_set.add(type) alternative.type_set.add(type) alternative.name = type.name.lower() alternative.content_id = content.id alternative.save() return alternative def process_options(self, content, alternative, cut): options = cut.findall('./option') order_pos = 0 for option in options: order_pos += 1 dialogue = self.write_line(content.id, cut.attrib['speaker'], option.find('./line').text) alt_line = models.GroupLine(group=alternative, line=dialogue, order=order_pos) alt_line.save() name = option.find('./name').text shots = option.findall('./shots/angle') for angle in shots: source = models.Source() source.file = name + '_' + angle.attrib['type'] + '.mp4' source.duration = float(angle.attrib['length']) * 1000 source.mime = 'video/mp4' source.size = angle.attrib['bytes'] source.save() line_source = models.LineSource(source=source, line=dialogue) line_source.save() def write_alt_type(self, cut): type = models.Type() if cut.attrib['alt']: subtype = cut.attrib['alt'] type.name = 'ALTERNATIVE' + '_' + subtype.upper() else: type.name = 'ALTERNATIVE' if 'paired' in subtype: position = int(cut.attrib['position'][0:1]) total = int(cut.attrib['position'][2:]) next = cut.attrib['next'] if 'next' in cut.attrib else None previous = cut.attrib['previous'] if 'previous' in cut.attrib else None data = {'pos': position, 'total': total, 'next':next, 'prev': previous} data_string = json.dumps(data) if 'mixed' in subtype: nested_positions = [] nested = cut.findall('./nested') nested_positions.append(int(nested[0].attrib['id'])) data['nested'] = nested_positions data_string = json.dumps(data) type.arguments = data_string if 'compound' in subtype: data = [{'default':1}] data_string = json.dumps(data) type.arguments = data_string type.save() return type def write_line(self, content_id, speaker, text): dialogue = models.Line() dialogue.line = text dialogue.speaker = speaker dialogue.content_id = content_id dialogue.save() return dialogue def dict_value(self, code): return self.dict.find('item/.[@code="{0}"]'.format(code)).attrib['content'] def dict_key(self, code): return self.dict.find('item/.[@content="{0}"]'.format(code)).attrib['code'] def get_scene_name(self, part_id): return models.Part.objects.get(pk=part_id).scene.title def truncate(self): models.Project.objects.all().delete() models.Script.objects.all().delete() models.Act.objects.all().delete() models.Scene.objects.all().delete() models.Part.objects.all().delete() models.Content.objects.all().delete() models.Item.objects.all().delete() models.Line.objects.all().delete() models.Group.objects.all().delete() models.Source.objects.all().delete() models.Type.objects.all().delete() models.ItemSource.objects.all().delete() models.LineSource.objects.all().delete() models.GroupSource.objects.all().delete() models.GroupItem.objects.all().delete() models.GroupLine.objects.all().delete()