API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Feb 2nd, 2018
86
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 14.33 KB | None | 0 0
raw download clone embed print report
  1. ########################################################################################################################
  2. #    File: Maria.py
  3. # Purpose: Class to make working with MariaDB/MySQL a lot easier.
  4. #  Author: Dan Huckson, https://github.com/unodan
  5. ########################################################################################################################
  6. import os
  7. import time
  8. import pymysql
  9. import logging as lg
  10. from dbslave.interface import *
  11.  
  12.  
  13.  
  14.  
  15.  
  16. class Interface(Instance):
  17.     def __init__(self, cache, log_file=None):
  18.         self.cache = cache
  19.         self.host = None
  20.         self.conn = None
  21.         self.cursor = None
  22.         self.db_name = None
  23.         self.db_user = None
  24.         self.db_password = None
  25.         self.class_name = self.__class__.__name__
  26.  
  27.         if not log_file:
  28.             log_file = self.class_name + '.log'
  29.  
  30.         lg.basicConfig(filename=log_file, format='%(levelname)s:%(name)s:%(asctime)s:%(message)s',
  31.             datefmt='%Y/%m/%d %I:%M:%S', level=lg.DEBUG)
  32.         lg.info('__init__:Object created')
  33.  
  34.     def use(self, database, **kwargs):
  35.         database = kwargs.pop('database', database)
  36.  
  37.         sql = 'USE %s' % database
  38.         try:
  39.             self.cursor.execute(sql)
  40.             self.db_name = database
  41.             self.set_autocommit(autocommit=kwargs.pop('autocommit', True))
  42.             lg.info('use:' + sql)
  43.             return True
  44.  
  45.         except Exception as err:
  46.             lg.error('use:' + str(err) + ':' + sql)
  47.  
  48.         return False
  49.  
  50.     def dump(self, database):
  51.         try:
  52.             t = time.strftime('%Y-%m-%d_%H:%M:%S')
  53.             os.popen('mysqldump -u %s -p%s -h %s -e --opt -c %s | gzip -c > %s.gz' % (
  54.                 self.db_user, self.db_password, self.host, database, database + '_' + t))
  55.             lg.info('dump:' + database + '_' + t + '.gz')
  56.             return True
  57.  
  58.         except Exception as err:
  59.             lg.error('dump:' + str(err))
  60.  
  61.         return False
  62.  
  63.     def close(self):
  64.         try:
  65.             self.cursor.close()
  66.             self.conn.close()
  67.             self.conn = None
  68.             self.cursor = None
  69.             lg.info('close:Closed database (%s)' % self.db_name)
  70.             self.db_name = None
  71.             return True
  72.  
  73.         except Exception as err:
  74.             lg.error('close:' + str(err))
  75.  
  76.         return False
  77.  
  78.     def commit(self):
  79.         try:
  80.             self.conn.commit()
  81.             lg.info('commit')
  82.             return True
  83.  
  84.         except Exception as err:
  85.             lg.error('commit:' + str(err))
  86.  
  87.         return False
  88.  
  89.     def connect(self, database=None, **kwargs):
  90.         cache = self.cache
  91.         database = self.db_name = kwargs.pop('database', database)
  92.  
  93.         try:
  94.             self.conn = pymysql.connect(host=cache['host'], port=cache['port'], user=cache['user'],
  95.                 passwd=cache['password'], charset=cache['charset'])
  96.  
  97.             self.db_user = cache['user']
  98.             self.db_password = cache['password']
  99.             self.host = cache['host']
  100.             self.cursor = self.conn.cursor()
  101.  
  102.             if database:
  103.                 if not self.database_exist(database):
  104.                     self.create_database(database)
  105.  
  106.                 self.use(database)
  107.  
  108.             lg.info('connect:Connection authenticated:(host={}, port={}, user={}, database={} charset={})'.
  109.                 format(cache['host'], cache['port'], cache['user'], database, cache['charset']))
  110.  
  111.             return True
  112.  
  113.         except Exception as err:
  114.             lg.error('connect:' + str(err))
  115.  
  116.         return False
  117.  
  118.     def execute(self, sql, args=None):
  119.         try:
  120.             if not args:
  121.                 self.cursor.execute(sql)
  122.             else:
  123.                 self.cursor.execute(sql, args)
  124.  
  125.             lg.info('execute:' + sql)
  126.             return True
  127.  
  128.         except Exception as err:
  129.             lg.error('execute:' + str(err) + ':' + sql)
  130.  
  131.         return False
  132.  
  133.     def fetchone(self):
  134.         try:
  135.             row = self.cursor.fetchone()
  136.             return row
  137.  
  138.         except Exception:
  139.             return False
  140.  
  141.     def fetchall(self):
  142.         try:
  143.             rows = self.cursor.fetchall()
  144.             return rows
  145.  
  146.         except Exception:
  147.             return False
  148.  
  149.     def drop_table(self, table):
  150.         sql = 'DROP TABLE %s' % table
  151.         try:
  152.             self.cursor.execute(sql)
  153.             lg.info('drop_table:' + sql)
  154.             return True
  155.  
  156.         except Exception as err:
  157.             lg.error('drop_table:' + str(err) + ':' + sql)
  158.  
  159.         return False
  160.  
  161.     def drop_index(self, table, index):
  162.         sql = 'DROP INDEX ' + index + ' ON ' + table + ';'
  163.         try:
  164.             self.cursor.execute(sql)
  165.             lg.info('drop_index:' + sql)
  166.             return True
  167.  
  168.         except Exception as err:
  169.             lg.error('drop_index:' + str(err) + ':' + sql)
  170.  
  171.         return False
  172.  
  173.     def drop_database(self, database, **kwargs):
  174.         database = kwargs.pop('database', database)
  175.  
  176.         sql = 'DROP DATABASE ' + database + ';'
  177.         try:
  178.             self.cursor.execute(sql)
  179.             lg.info('drop_database:' + sql)
  180.             return True
  181.  
  182.         except Exception as err:
  183.             lg.error('drop_database:' + str(err) + ':' + sql)
  184.  
  185.         return False
  186.  
  187.     def create_table(self, table, sql, **kwargs):
  188.         sql = 'CREATE TABLE ' + table + ' (' + sql + ') ENGINE=%s;'
  189.         database = kwargs.pop('database', self.db_name)
  190.         database_engine = kwargs.pop('database_engine', 'InnoDB')
  191.  
  192.         try:
  193.             if database == self.db_name:
  194.                 self.cursor.execute(sql, (database_engine,))
  195.             else:
  196.                 db = self.db_name
  197.                 self.use(database)
  198.                 self.cursor.execute(sql)
  199.                 self.use(db)
  200.  
  201.             lg.info('create_table:' + sql)
  202.             return True
  203.  
  204.         except Exception as err:
  205.             lg.error('create_table:' + str(err) + ':' + sql)
  206.  
  207.         return False
  208.  
  209.     def create_index(self, table, column, index):
  210.         sql = 'CREATE INDEX ' + index + ' ON ' + table + '(' + column + ');'
  211.         try:
  212.             self.cursor.execute(sql)
  213.             lg.info('create_index:' + sql)
  214.             return True
  215.  
  216.         except Exception as err:
  217.             exit()
  218.             lg.error('create_index:' + str(err) + ':' + sql)
  219.  
  220.         return False
  221.  
  222.     def create_database(self, database, **kwargs):
  223.         database = kwargs.pop('database', database)
  224.  
  225.         sql = 'CREATE DATABASE %s;' % database
  226.         try:
  227.             self.cursor.execute(sql)
  228.             lg.info('create_database:' + sql)
  229.             return True
  230.  
  231.         except Exception as err:
  232.             lg.error('create_database:' + str(err) + ':' + sql)
  233.  
  234.         return False
  235.  
  236.     def row_exist(self, table, id):
  237.         sql = 'SELECT id FROM ' + table + ' WHERE id=%s;'
  238.         if self.execute(sql, (id,)):
  239.             if self.fetchone():
  240.                 return True
  241.  
  242.         return False
  243.  
  244.     def table_exist(self, table, **kwargs):
  245.         sql = 'SELECT table_name FROM information_schema.tables WHERE table_schema=%s AND table_name=%s;'
  246.  
  247.         database = kwargs.pop('database', self.db_name)
  248.  
  249.         try:
  250.             self.cursor.execute(sql, (database, table))
  251.             if self.cursor.fetchone():
  252.                 return True
  253.  
  254.         except Exception as err:
  255.             lg.error('table_exist:' + str(err))
  256.  
  257.         return False
  258.  
  259.     def index_exist(self, table, index, **kwargs):
  260.         result = False
  261.         database = kwargs.pop('database', self.db_name)
  262.  
  263.         if database:
  264.             sql = 'SELECT 1 FROM information_schema.statistics WHERE table_schema="' + database + '" AND ' \
  265.                   'table_name="' + table + '" AND index_name="' + index + '";'
  266.  
  267.             try:
  268.                 if database == self.db_name:
  269.                     if self.cursor.execute(sql) and self.cursor.fetchone():
  270.                         result = True
  271.                 else:
  272.                     db_name = self.db_name
  273.                     self.use(database)
  274.                     if self.cursor.execute(sql) and self.cursor.fetchone():
  275.                         result = True
  276.                     self.use(db_name)
  277.  
  278.             except Exception as err:
  279.                 lg.error('index_exist:' + str(err))
  280.  
  281.         return result
  282.  
  283.     def database_exist(self, database, **kwargs):
  284.         database = kwargs.pop('database', database)
  285.  
  286.         sql = 'SHOW DATABASES;'
  287.         try:
  288.             self.cursor.execute(sql)
  289.             for r in self.cursor.fetchall():
  290.                 if database in r:
  291.                     return True
  292.  
  293.         except Exception as err:
  294.             lg.error('database_exist:' + str(err))
  295.  
  296.         return False
  297.  
  298.     def insert_row(self, table, row):
  299.         parts = ''
  300.         sql = 'INSERT INTO ' + table + ' ('
  301.         for f in row:
  302.             parts += (f + ',')
  303.         sql = sql + parts[:-1] + ') VALUES ('
  304.  
  305.         parts = ''
  306.         for f in row:
  307.             parts += '%s,'
  308.         sql = sql + parts[:-1] + ');'
  309.  
  310.         data = []
  311.         for c in row:
  312.             data.append(row[c])
  313.  
  314.         try:
  315.             self.cursor.execute(sql, tuple(data))
  316.             lg.info('insert_row:' + sql)
  317.             return True
  318.  
  319.         except Exception as err:
  320.             lg.error('insert_row:' + str(err) + ':' + sql)
  321.  
  322.         return False
  323.  
  324.     def update_row(self, table, row, id):
  325.         parts = ''
  326.         sql = 'UPDATE ' + table + ' SET '
  327.         for f in row:
  328.             parts += (f + '=%s,')
  329.         sql = sql + parts[:-1] + ' WHERE id=%s;'
  330.  
  331.         data = []
  332.         for c in row:
  333.             data.append(row[c])
  334.         data.append(id)
  335.  
  336.         try:
  337.             self.cursor.execute(sql, tuple(data))
  338.             lg.info('update_row:' + sql)
  339.             return True
  340.  
  341.         except Exception as err:
  342.             lg.error('update_row:' + str(err) + ':' + sql)
  343.  
  344.         return False
  345.  
  346.     def delete_row(self, table, id):
  347.         sql = 'DELETE FROM ' + table + ' WHERE id = %s;'
  348.         try:
  349.             self.cursor.execute(sql, (id,))
  350.             lg.info('delete_row:' + sql)
  351.             return True
  352.  
  353.         except Exception as err:
  354.             lg.error('delete_row:' + str(err) + ':' + sql)
  355.  
  356.         return False
  357.  
  358.     def get_databases(self):
  359.         sql = 'SHOW DATABASES;'
  360.         try:
  361.             self.cursor.execute(sql)
  362.             rows = self.cursor.fetchall()
  363.             if rows:
  364.                 return tuple([i[0] for i in rows])
  365.  
  366.         except Exception as err:
  367.             lg.error('get_databases:' + str(err) + ':' + sql)
  368.  
  369.         return False
  370.  
  371.     def get_schema_names(self):
  372.         return False
  373.  
  374.     def get_tables(self, database=None, **kwargs):
  375.         if not database:
  376.             database = self.db_name
  377.  
  378.         sql = "SHOW TABLES;"
  379.         database = kwargs.pop('database', database)
  380.  
  381.         try:
  382.             if database == self.db_name:
  383.                 self.cursor.execute(sql)
  384.                 rows = self.cursor.fetchall()
  385.             else:
  386.                 db = self.db_name
  387.                 self.use(database)
  388.                 self.cursor.execute(sql)
  389.                 rows = self.cursor.fetchall()
  390.                 self.use(db)
  391.  
  392.             if rows:
  393.                 return tuple([i[0] for i in rows])
  394.  
  395.         except Exception as err:
  396.             lg.error('get_tables:' + str(err) + ':' + sql)
  397.  
  398.         return False
  399.  
  400.     def get_column_metadata(self, table, column, **kwargs):
  401.         database = kwargs.pop('database', self.db_name)
  402.  
  403.         sql = "SELECT * FROM information_schema.COLUMNS WHERE " \
  404.               "TABLE_SCHEMA='" + database + "' AND " \
  405.               "TABLE_NAME = '" + table + "' AND " \
  406.               "COLUMN_NAME = '" + column + "';"
  407.         try:
  408.             if database == self.db_name:
  409.                 self.cursor.execute(sql)
  410.                 rows = self.cursor.fetchall()
  411.             else:
  412.                 db = self.db_name
  413.                 self.use(database)
  414.                 self.cursor.execute(sql)
  415.                 rows = self.cursor.fetchall()
  416.                 self.use(db)
  417.  
  418.             if rows:
  419.                 return tuple(rows)
  420.  
  421.         except Exception as err:
  422.             lg.error('get_databases:' + str(err) + ':' + sql)
  423.  
  424.         return False
  425.  
  426.     def get_columns_metadata(self, table, **kwargs):
  427.         database = kwargs.pop('database', self.db_name)
  428.  
  429.         sql = "SELECT * FROM information_schema.COLUMNS WHERE " \
  430.               "TABLE_SCHEMA='" + database + "' AND " \
  431.               "TABLE_NAME = '" + table + "';"
  432.  
  433.         try:
  434.             if database == self.db_name:
  435.                 self.cursor.execute(sql)
  436.                 rows = self.cursor.fetchall()
  437.             else:
  438.                 db = self.db_name
  439.                 self.use(database)
  440.                 self.cursor.execute(sql)
  441.                 rows = self.cursor.fetchall()
  442.                 self.use(db)
  443.             if rows:
  444.                 return tuple(rows)
  445.  
  446.         except Exception as err:
  447.             lg.error('get_columns_metadata:' + str(err) + ':' + sql)
  448.  
  449.         return False
  450.  
  451.     #############################################
  452.  
  453.     def set_autocommit(self, **kwargs):
  454.         sql = 'SET AUTOCOMMIT = %s;' % kwargs.pop('autocommit', True)
  455.  
  456.         try:
  457.             self.cursor.execute(sql)
  458.             lg.info('set_autocommit:' + sql)
  459.             return True
  460.  
  461.         except Exception as err:
  462.             lg.error('set_autocommit:' + str(err) + ':' + sql)
  463.  
  464.         return False
  465.  
  466.     def get_table_status(self, table=None, **kwargs):
  467.         sql = "SHOW TABLE STATUS"
  468.         database = kwargs.pop('database', self.db_name)
  469.  
  470.         if table:
  471.             sql += " WHERE Name='" + table + "'"
  472.  
  473.         if database or table:
  474.             try:
  475.                 if database == self.db_name:
  476.                     self.cursor.execute(sql)
  477.                     rows = self.cursor.fetchall()
  478.                 else:
  479.                     db = self.db_name
  480.                     self.use(database)
  481.                     self.cursor.execute(sql)
  482.                     rows = self.cursor.fetchall()
  483.                     self.use(db)
  484.  
  485.                 if rows:
  486.                     return rows
  487.  
  488.             except Exception as err:
  489.                 lg.error('get_table_status:' + str(err) + ':' + sql)
  490.  
  491.         return False
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!