Paramiko和MySQL相关-day10

transport = paramiko.Transport((‘95.163.199.239‘,端口))
transport.connect(username=‘用户‘,password=‘密码‘)
ssh = paramiko.SSHClient()
ssh._transport = transport
stdin,stdout,stderr = ssh.exec_command(‘df‘)
print(stdout.read().decode(‘utf-8‘))
transport.close()

key_file = open(r‘E:\filename\filename\id_rsa_2048‘)
rsa_key = paramiko.RSAKey.from_private_key(key_file,‘rsa_password‘)
transport = paramiko.Transport((‘95.163.199.239‘,port))
transport.connect(username=‘root‘,pkey=rsa_key)
ssh = paramiko.SSHClient()
ssh._transport = transport
stdin,stdout,stderr = ssh.exec_command(‘df‘)
print(stdout.read().decode(‘utf-8‘))
transport.close()

class SSH_Client(object):
    def __init__(self,host=None,port=None,username=None,password=None):
        self.host = host
        self.port = port
        self.username = username
        self.password = password
        self._transport = None

    def run(self):
        self.conn()

    def conn(self):
        transport = paramiko.Transport((self.host,self.port))
        transport.connect(username=self.username,password=self.password)
        self._transport = transport
    def close(self):
        self._transport.close()

    def command(self):
        ssh = paramiko.SSHClient()
        ssh._transport = self._transport
        while True:
            command = input(‘[localhost~]#:‘).strip()
            if command:
                if command == "exit":
                    self.close()
                    exit()
                else:
                    stdin,stdout,stderr = ssh.exec_command(command)
                    print(stdout.read().decode(‘utf-8‘))
            else:
                continue


ssh = SSH_Client()
ssh.run()

用户名@IP地址         用户只能在改IP下才能访问
 用户名@192.168.1.%   用户只能在改IP段下才能访问(通配符%表示任意)
用户名@%   用户可以再任意IP下访问(默认IP地址为%)

grant all privileges on db1.tb1 TO ‘用户名‘@‘IP‘

            grant select on db1.* TO ‘用户名‘@‘IP‘

            grant select,insert on *.* TO ‘用户名‘@‘IP‘

            revoke select on db1.tb1 from ‘用户名‘@‘IP‘

示例

多对多
        create table deparment(id int not null auto_increment primary key,title char(32) null,)
        
        create table host(id int not null auto_increment primary key,ip char(32) null,port int null,)
        
        create table deparment_to_host(id int not null auto_increment primary key,did int not null,hid int not null,constraint fk_did_deparment foreign key (did) references deparment(id),constraint fk_hid_host foreign key (hid) references host(id))

bit[(M)]
            二进制位（101001），m表示二进制位的长度（1-64），默认m＝1

        tinyint[(m)] [unsigned] [zerofill]

            小整数，数据类型用于保存一些范围的整数数值范围：
            有符号：
                -128 ～ 127.
            无符号：
～ 255

            特别的： MySQL中无布尔值，使用tinyint(1)构造。

        int[(m)][unsigned][zerofill]

            整数，数据类型用于保存一些范围的整数数值范围：
                有符号：
                    -2147483648 ～ 2147483647
                无符号：
～ 4294967295

            特别的：整数类型中的m仅用于显示，对存储范围无限制。例如： int(5),当插入数据2时，select 时数据显示为： 00002

        bigint[(m)][unsigned][zerofill]
            大整数，数据类型用于保存一些范围的整数数值范围：
                有符号：
                    -9223372036854775808 ～ 9223372036854775807
                无符号：
 ～  18446744073709551615

        decimal[(m[,d])] [unsigned] [zerofill]
            准确的小数值，m是数字总个数（负号不算），d是小数点后个数。 m最大值为65，d最大值为30。

            特别的：对于精确数值计算时需要用此类型
                   decaimal能够存储精确值的原因在于其内部按照字符串存储。

        FLOAT[(M,D)] [UNSIGNED] [ZEROFILL]
            单精度浮点数（非准确小数值），m是数字总个数，d是小数点后个数。
                无符号：
                    -3.402823466E+38 to -1.175494351E-38,
                    1.175494351E-38 to 3.402823466E+38
                有符号：
                    1.175494351E-38 to 3.402823466E+38

            **** 数值越大，越不准确 ****

        DOUBLE[(M,D)] [UNSIGNED] [ZEROFILL]
            双精度浮点数（非准确小数值），m是数字总个数，d是小数点后个数。

                无符号：
                    -1.7976931348623157E+308 to -2.2250738585072014E-308
                    2.2250738585072014E-308 to 1.7976931348623157E+308
                有符号：
                    2.2250738585072014E-308 to 1.7976931348623157E+308
            **** 数值越大，越不准确 ****


        char (m)
            char数据类型用于表示固定长度的字符串，可以包含最多达255个字符。其中m代表字符串的长度。
            PS: 即使数据小于m长度，也会占用m长度
        varchar(m)
            varchars数据类型用于变长的字符串，可以包含最多达255个字符。其中m代表该数据类型所允许保存的字符串的最大长度，只要长度小于该最大值的字符串都可以被保存在该数据类型中。

            注：虽然varchar使用起来较为灵活，但是从整个系统的性能角度来说，char数据类型的处理速度更快，有时甚至可以超出varchar处理速度的50%。因此，用户在设计数据库时应当综合考虑各方面的因素，以求达到最佳的平衡

        text
            text数据类型用于保存变长的大字符串，可以组多到65535 (2**16 ? 1)个字符。

        mediumtext
            A TEXT column with a maximum length of 16,777,215 (2**24 ? 1) characters.

        longtext
            A TEXT column with a maximum length of 4,294,967,295 or 4GB (2**32 ? 1) characters.


        enum
            枚举类型，
            An ENUM column can have a maximum of 65,535 distinct elements. (The practical limit is less than 3000.)
            示例：
                CREATE TABLE shirts (
                    name VARCHAR(40),
                    size ENUM(‘x-small‘, ‘small‘, ‘medium‘, ‘large‘, ‘x-large‘)
                );
                INSERT INTO shirts (name, size) VALUES (‘dress shirt‘,‘large‘), (‘t-shirt‘,‘medium‘),(‘polo shirt‘,‘small‘);

        set
            集合类型
            A SET column can have a maximum of 64 distinct members.
            示例：
                CREATE TABLE myset (col SET(‘a‘, ‘b‘, ‘c‘, ‘d‘));
                INSERT INTO myset (col) VALUES (‘a,d‘), (‘d,a‘), (‘a,d,a‘), (‘a,d,d‘), (‘d,a,d‘);

        DATE
            YYYY-MM-DD（1000-01-01/9999-12-31）

        TIME
            HH:MM:SS（‘-838:59:59‘/‘838:59:59‘）

        YEAR
            YYYY（1901/2155）

        DATETIME

            YYYY-MM-DD HH:MM:SS（1000-01-01 00:00:00/9999-12-31 23:59:59    Y）

        TIMESTAMP

            YYYYMMDD HHMMSS（1970-01-01 00:00:00/2037 年某时）

a、条件
    select * from 表 where id > 1 and name != ‘alex‘ and num = 12;
 
    select * from 表 where id between 5 and 16;
 
    select * from 表 where id in (11,22,33)
    select * from 表 where id not in (11,22,33)
    select * from 表 where id in (select nid from 表)
 
b、通配符
    select * from 表 where name like ‘ale%‘  - ale开头的所有（多个字符串）
    select * from 表 where name like ‘ale_‘  - ale开头的所有（一个字符）
 
c、限制
    select * from 表 limit 5;            - 前5行
    select * from 表 limit 4,5;          - 从第4行开始的5行
    select * from 表 limit 5 offset 4    - 从第4行开始的5行
 
d、排序
    select * from 表 order by 列 asc              - 根据 “列” 从小到大排列
    select * from 表 order by 列 desc             - 根据 “列” 从大到小排列
    select * from 表 order by 列1 desc,列2 asc    - 根据 “列1” 从大到小排列，如果相同则按列2从小到大排序
 
e、分组
    select num from 表 group by num
    select num,nid from 表 group by num,nid
    select num,nid from 表  where nid > 10 group by num,nid order nid desc
    select num,nid,count(*),sum(score),max(score),min(score) from 表 group by num,nid
 
    select num from 表 group by num having max(id) > 10
 
    特别的：group by 必须在where之后，order by之前
 
f、连表
    无对应关系则不显示
    select A.num, A.name, B.name
    from A,B
    Where A.nid = B.nid
 
    无对应关系则不显示
    select A.num, A.name, B.name
    from A inner join B
    on A.nid = B.nid
 
    A表所有显示，如果B中无对应关系，则值为null
    select A.num, A.name, B.name
    from A left join B
    on A.nid = B.nid
 
    B表所有显示，如果B中无对应关系，则值为null
    select A.num, A.name, B.name
    from A right join B
    on A.nid = B.nid
 
g、组合
    组合，自动处理重合
    select nickname
    from A
    union
    select name
    from B
 
    组合，不处理重合
    select nickname
    from A
    union all
    select name
    from B

-- show tables;
-- create TABLE nothing(id int not NULL auto_increment PRIMARY KEY,name CHAR(20) null);
-- show tables;
-- create student(sid INT not null auto_increment PRIMARY key,name char(20) not null,
-- student_cid)
-- create table tearcher(tid int not NULL auto_increment PRIMARY KEY,tearcher_name char(20) null)
-- create table class(cid int not null auto_increment PRIMARY key,
-- class_name char(20),
-- class_tid int not null,
-- CONSTRAINT fk_class_tid_to_tearcher FOREIGN KEY (class_tid) REFERENCES tearcher(tid));

-- CREATE TABLE student(
-- id int not null auto_increment PRIMARY KEY,
-- student_name CHAR(20),
-- student_cid int not NULL,
-- CONSTRAINT student_cid_to_class FOREIGN KEY (student_cid) REFERENCES class(cid)
-- );

-- create table course(
-- cid int not null auto_increment PRIMARY key,
-- course_name char(20),
-- course_tid INT not NULL,
-- CONSTRAINT student_cid_to_tearcher FOREIGN KEY (course_tid) REFERENCES tearcher(tid)
-- );

-- create table score(sid int not null auto_increment PRIMARY KEY,
-- number int,
-- score_sid int not NULL,
-- score_cid int not NULL,
-- CONSTRAINT score_sid_to_student FOREIGN KEY (score_sid) REFERENCES student(id),
-- CONSTRAINT score_cid_to_course FOREIGN KEY (score_cid) REFERENCES course(cid)
-- );

-- INSERT INTO tearcher(tearcher_name) VALUES("张三");
-- INSERT INTO tearcher(tearcher_name) VALUES("李四");
-- INSERT INTO tearcher(tearcher_name) VALUES("王二");
-- INSERT INTO tearcher(tearcher_name) VALUES("天道");

-- INSERT INTO class(class_name,class_tid)  VALUES (‘四年三班‘,‘1‘);
-- INSERT INTO class(class_name,class_tid)  VALUES (‘四年四班‘,‘2‘);
-- INSERT INTO class(class_name,class_tid)  VALUES (‘四年五班‘,‘3‘);
-- INSERT INTO class(class_name,class_tid)  VALUES (‘四年六班‘,‘4‘);
-- INSERT INTO class(class_name,class_tid)  VALUES (‘五年一班‘,‘1‘);

-- INSERT INTO student(student_name,student_cid) VALUES (‘Leon‘,‘1‘);
-- INSERT INTO student(student_name,student_cid) VALUES (‘麻子‘,‘1‘);
-- INSERT INTO student(student_name,student_cid) VALUES (‘胡志虎‘,‘1‘);
-- INSERT INTO student(student_name,student_cid) VALUES (‘乔jj‘,‘1‘);
-- INSERT INTO student(student_name,student_cid) VALUES (‘老毛‘,‘1‘);
-- INSERT INTO student(student_name,student_cid) VALUES (‘张累‘,‘1‘);
-- INSERT INTO student(student_name,student_cid) VALUES (‘张耀‘,‘1‘);
-- INSERT INTO student(student_name,student_cid) VALUES (‘瑶瑶‘,‘2‘);
-- INSERT INTO student(student_name,student_cid) VALUES (‘小明‘,‘2‘);
-- INSERT INTO student(student_name,student_cid) VALUES (‘小王‘,‘2‘);
-- INSERT INTO student(student_name,student_cid) VALUES (‘小花‘,‘2‘);
-- INSERT INTO student(student_name,student_cid) VALUES (‘陈丹丹‘,‘3‘);
-- INSERT INTO student(student_name,student_cid) VALUES (‘老魏‘,‘3‘);
-- INSERT INTO student(student_name,student_cid) VALUES (‘天机‘,‘3‘);
-- INSERT INTO student(student_name,student_cid) VALUES (‘大师‘,‘4‘);
-- INSERT INTO student(student_name,student_cid) VALUES (‘若尘‘,‘4‘);
-- INSERT INTO student(student_name,student_cid) VALUES (‘明镜‘,‘4‘);
-- INSERT INTO student(student_name,student_cid) VALUES (‘明堂‘,‘4‘);


-- INSERT INTO course(course_name,course_tid) VALUES (‘生物‘,‘1‘);
-- INSERT INTO course(course_name,course_tid) VALUES (‘语文‘,‘2‘);
-- INSERT INTO course(course_name,course_tid) VALUES (‘数学‘,‘3‘);
-- INSERT INTO course(course_name,course_tid) VALUES (‘英文‘,‘4‘);

-- INSERT INTO score(number,score_sid,score_cid) VALUES (‘20‘,‘1‘,‘1‘);
-- INSERT INTO score(number,score_sid,score_cid) VALUES (‘30‘,‘1‘,‘2‘);
-- INSERT INTO score(number,score_sid,score_cid) VALUES (‘40‘,‘1‘,‘3‘);
-- INSERT INTO score(number,score_sid,score_cid) VALUES (‘50‘,‘1‘,‘4‘);
-- INSERT INTO score(number,score_sid,score_cid) VALUES (‘50‘,‘2‘,‘1‘);
-- INSERT INTO score(number,score_sid,score_cid) VALUES (‘40‘,‘2‘,‘2‘);
-- INSERT INTO score(number,score_sid,score_cid) VALUES (‘30‘,‘2‘,‘3‘);
-- INSERT INTO score(number,score_sid,score_cid) VALUES (‘20‘,‘2‘,‘4‘);
-- INSERT INTO score(number,score_sid,score_cid) VALUES (‘25‘,‘3‘,‘1‘);
-- INSERT INTO score(number,score_sid,score_cid) VALUES (‘15‘,‘3‘,‘2‘);
-- INSERT INTO score(number,score_sid,score_cid) VALUES (‘35‘,‘3‘,‘3‘);
-- INSERT INTO score(number,score_sid,score_cid) VALUES (‘45‘,‘3‘,‘4‘);
-- INSERT INTO score(number,score_sid,score_cid) VALUES (‘45‘,‘4‘,‘1‘);
-- INSERT INTO score(number,score_sid,score_cid) VALUES (‘35‘,‘4‘,‘2‘);
-- INSERT INTO score(number,score_sid,score_cid) VALUES (‘25‘,‘4‘,‘3‘);
-- INSERT INTO score(number,score_sid,score_cid) VALUES (‘15‘,‘4‘,‘4‘);

conn= memcache.Client([(‘1.1.1.1:12000‘, 1), (‘1.1.1.2:12000‘, 2), (‘1.1.1.3:12000‘, 1)], debug=True)

conn.set(‘k1‘,‘v1‘)