0001-临时

sonehb

已于 2024-01-25 21:54:56 修改

阅读量515

点赞数

分类专栏：临时文章标签： ajax

于 2018-08-31 18:03:46 首次发布

本文链接：https://blog.csdn.net/weixin_42725107/article/details/82019573

版权

临时专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Django-apscheduler是一个基于apscheduler库的Python定时任务调度库

https://zhuanlan.zhihu.com/p/665261202

https://xugaoxiang.com/2020/07/17/python-module-apscheduler/

https://apscheduler.readthedocs.io/en/3.x/userguide.html

在这里插入图片描述

https://blog.51cto.com/u_15349841/6672681

https://www.cnblogs.com/guojie-guojie/p/16330165.html

https://blog.csdn.net/hxryb/article/details/112787681

https://blog.csdn.net/linZinan_/article/details/132607165

https://www.cnblogs.com/thankcat/p/17881353.html

def test(com, v, type):
    if com != v:
        v_1 = com[type]
        if not isinstance(v_1, list):
            com[type] = [v_1] if v_1 else []

        if isinstance(v[type], list):
            com[type].extend(v[type])
        else:
            if v[type]:
                com[type].append(v[type])

        if not com[type]:
            com[type] = ""

def one(a, b):
    c = a.copy()
    a.update(b)
    for k, v in c.items():
        test(a[k], v, "stable")
        test(a[k], v, "rc")
        test(a[k], v, "legacy")
    return a

if __name__ == '__main__':

    a = {
        "root": {
            "stable": "aa",
            "rc": "AA",
            "legacy": "",
        },
        "web": {
            "stable": "bb",
            "rc": "BB",
            "legacy": "",
        },
        "pp": {
            "stable": "11",
            "rc": "22",
            "legacy": "",
        }
    }

    b = {
        "root": {
            "stable": "aa_2",
            "rc": "AA_2",
            "legacy": "",
        },
        "web": {
            "stable": "bb_2",
            "rc": "BB_2",
            "legacy": "",
        },
        "pay": {
            "stable": "cc_2",
            "rc": "CC_2",
            "legacy": "",
        }
    }

    one(a.copy(), b)

    print('*****')
    print(a)

CREATE OR REPLACE FUNCTION jg.func_query_table_row_count(out o_name varchar,out o_id integer)
 RETURNS SETOF RECORD as
$$
DECLARE
    v_rec RECORD;
	result RECORD;
	o_sql varchar;
BEGIN
  
   	for v_rec in select tablename from pg_tables where schemaname = 'jg' order by tablename loop
		o_name := v_rec.tablename;
		o_sql := 'select count(*) count from jg.' || v_rec.tablename;
		FOR result IN EXECUTE o_sql LOOP
			o_id := result.count;
		END LOOP;
		RETURN NEXT ;
   	end loop;
   	return;
END;
$$
LANGUAGE PLPGSQL;

select  jg.func_query_table_row_count();

<template>
    <div ref="editor"></div>
</template>

<script>
    export default {
        name: "editor",
        props: ['content'],
        data() {
            return {
                _content: '',
            }
        },
        watch: {
            //  监听父组件传递的content值，变化后更新富文本内容
            content(newVal, oldVal) {
                if (this.quill) {
                    if (newVal && newVal !== this._content) {
                        this._content = newVal;
                        this.quill.clipboard.dangerouslyPasteHTML(newVal);
                    } else if(!newVal) {
                        this.quill.setText('');
                    }
                }
            }
        },
        methods: {
            uploadToServer(file, callback) {
                var xhr = new XMLHttpRequest();
                var formData = new FormData();
                formData.append('upload', file);
                xhr.open('post', this.$ajax.defaults.baseURL + '/upload/blogUpload');
                xhr.withCredentials = true;
                xhr.responseType = 'json';
                xhr.send(formData);
                xhr.onreadystatechange = () => {
                    if (xhr.readyState == 4 && xhr.status == 200) {
                        callback(xhr.response);
                    }
                };
            }
        },
        mounted() {
            //  初始化quill
            this.quill = new Quill(this.$refs.editor, {
                theme: 'snow',
                modules: {
                    history: {
                        userOnly: true
                    },
                    toolbar: [
                        ['bold', 'italic', 'underline', 'strike'],
                        ['blockquote', 'code-block'],
                        [{ 'list': 'ordered' }, { 'list': 'bullet' }],
                        [{ 'script': 'sub' }, { 'script': 'super' }],
                        [{ 'header': [1, 2, 3, 4, 5, 6, false] }],
                        [{ 'color': [] }, { 'background': [] }],
                        [{ 'align': [] }],
                        ['clean'],
                        ['link', 'image', 'video']
                    ],
                    syntax: true
                }
            });

            //  自定义粘贴图片功能
            this.quill.root.addEventListener('paste', evt => {
                if (evt.clipboardData && evt.clipboardData.files && evt.clipboardData.files.length) {
                    evt.preventDefault();
                    [].forEach.call(evt.clipboardData.files, file => {
                        if (!file.type.match(/^image\/(gif|jpe?g|a?png|bmp)/i)) {
                            return;
                        }
                        this.uploadToServer(file, (res) => {
                            var range = this.quill.getSelection();
                            if (range) {
                                //  在当前光标位置插入图片
                                toolbar.quill.insertEmbed(range.index, 'image', this.$ajax.defaults.baseURL + res.file.path);
                                //  将光标移动到图片后面
                                toolbar.quill.setSelection(range.index + 1);
                            }
                        });
                    });
                }
            }, false);

            //  监听富文本变化，更新父组件数据
            this.quill.on('text-change', () => {
                let html = this.$refs.editor.children[0].innerHTML;
                if (html === '<p><br></p>') html = '';
                this._content = html;
                this.$emit('edit', this._content);
            });
        }
    }
</script>

<style>
    .ql-snow .ql-editor pre.ql-syntax {
        background-color: #282c34;
        color: #abb2bf;
    }
</style>

INSERT INTO `test2`.`a_cls`(`id`, `cls`) VALUES (100, '一年级');
INSERT INTO `test2`.`a_cls`(`id`, `cls`) VALUES (200, '二年级');
INSERT INTO `test2`.`a_cls`(`id`, `cls`) VALUES (300, '三年级');

INSERT INTO `test2`.`a_subject`(`id`, `cid`, `subjects`) VALUES (1000, 100, '语文');
INSERT INTO `test2`.`a_subject`(`id`, `cid`, `subjects`) VALUES (1001, 100, '数学');
INSERT INTO `test2`.`a_subject`(`id`, `cid`, `subjects`) VALUES (1002, 100, '英语');
INSERT INTO `test2`.`a_subject`(`id`, `cid`, `subjects`) VALUES (2000, 200, '语文');
INSERT INTO `test2`.`a_subject`(`id`, `cid`, `subjects`) VALUES (2001, 200, '数学');
INSERT INTO `test2`.`a_subject`(`id`, `cid`, `subjects`) VALUES (2002, 200, '英语');
INSERT INTO `test2`.`a_subject`(`id`, `cid`, `subjects`) VALUES (3000, 300, '语文');
INSERT INTO `test2`.`a_subject`(`id`, `cid`, `subjects`) VALUES (3001, 300, '数学');
INSERT INTO `test2`.`a_subject`(`id`, `cid`, `subjects`) VALUES (3002, 300, '英语');

INSERT INTO `test2`.`a_user`(`id`, `cid`, `uname`) VALUES (1, 100, 'tom1');
INSERT INTO `test2`.`a_user`(`id`, `cid`, `uname`) VALUES (2, 100, 'cat1');
INSERT INTO `test2`.`a_user`(`id`, `cid`, `uname`) VALUES (3, 100, 'kitty1');
INSERT INTO `test2`.`a_user`(`id`, `cid`, `uname`) VALUES (4, 200, 'tom2');
INSERT INTO `test2`.`a_user`(`id`, `cid`, `uname`) VALUES (5, 200, 'cat2');
INSERT INTO `test2`.`a_user`(`id`, `cid`, `uname`) VALUES (6, 200, 'kitty2');
INSERT INTO `test2`.`a_user`(`id`, `cid`, `uname`) VALUES (7, 300, 'tom3');
INSERT INTO `test2`.`a_user`(`id`, `cid`, `uname`) VALUES (8, 300, 'cat3');
INSERT INTO `test2`.`a_user`(`id`, `cid`, `uname`) VALUES (9, 300, 'kitty3');

INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10000, 1, 1000, 50);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10001, 1, 1001, 80);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10002, 1, 1002, 99);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10003, 2, 1000, 97);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10004, 2, 1001, 100);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10005, 2, 1002, 60);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10006, 3, 1000, 80);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10007, 3, 1001, 86);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10008, 3, 1002, 70);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10009, 4, 1000, 10);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10010, 4, 1001, 100);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10011, 4, 1002, 80);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10012, 5, 1000, 58);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10013, 5, 1001, 70);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10014, 5, 1002, 96);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10015, 6, 1000, 88);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10016, 6, 1001, 72);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10017, 6, 1002, 66);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10018, 7, 1000, 82);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10019, 7, 1001, 76);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10020, 7, 1002, 30);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10021, 8, 1000, 90);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10022, 8, 1001, 40);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10023, 8, 1002, 56);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10024, 9, 1000, 98);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10025, 9, 1001, 100);
INSERT INTO `test2`.`a_score`(`id`, `uid`, `sbid`, `scores`) VALUES (10026, 9, 1002, 96);

https://blog.csdn.net/qq_30273259/article/details/62224217


https://blog.csdn.net/lvluobo/article/details/80979038

https://pypi.org/project/django-cronman/#description

STATICFILES_FINDERS = [
    'django.contrib.staticfiles.finders.FileSystemFinder',
    'django.contrib.staticfiles.finders.AppDirectoriesFinder',
]

import java.util.ArrayList;
import java.util.List;

import org.pentaho.di.core.encryption.Encr;
import org.pentaho.di.core.util.StringUtil;

public class Test2 {
	public static final String PASSWORD_ENCRYPTED_PREFIX = "Encrypted ";

	public static final String encryptPasswordIfNotUsingVariables(
			String password) {
		String encrPassword = "";
		List<String> varList = new ArrayList<String>();
		System.out.println(varList);
		StringUtil.getUsedVariables(password, varList, true);
		if (varList.isEmpty()) {
			System.out.println("1111111111");
			encrPassword = PASSWORD_ENCRYPTED_PREFIX
					+ Encr.encryptPassword(password);

		} else {
			System.out.println("22222222");
			encrPassword = password;
		}
		return encrPassword;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		System.out.println(Test2
				.encryptPasswordIfNotUsingVariables("aaabbb"));
		// Encrypted 2be98afc86aa7f2e4cb79af71df90add8
		// Encrypted 2be98afc86aa7f2e4cb79af71df90add8

		String pw = Encr.encryptPassword("aaabbb");
		System.out.println(pw);
		System.out.println(pw.length());
	}

}

-- ORACLE
SELECT COUNT(TABLE_NAME) FROM ALL_TABLES WHERE OWNER = UPPER('SCOTT') AND TABLE_NAME = UPPER('atab')

-- mysql
SELECT count(table_name) FROM information_schema.TABLES WHERE table_schema = 'mysqldb' and table_name ='atab'

--pgsql
select count(table_name) from information_schema.tables where table_schema='jg' and table_type='BASE TABLE' and table_name='auser'

--sql server
select count(name) from dbo.sysobjects where id = object_id(N'[guest].[atab]') and OBJECTPROPERTY(id, N'IsUserTable') = 1

response["Access-Control-Allow-Origin"] = "*"
response["Access-Control-Allow-Methods"] = "POST, GET, OPTIONS"
response["Access-Control-Max-Age"] = "1000"
response["Access-Control-Allow-Headers"] = "*"

-- Oracle
COMMENT ON COLUMN ROOT.AUSER.ID IS '用户表ID';

-- MySQL
alter table mysqldb.atab modify column id int comment 'atab id 注释';

-- PgSQL
comment on column jg.auser.id is '主键ID，自增';

-- SQL SERVER
EXEC sys.sp_addextendedproperty @name=N'MS_Description', @value=N'主键idaaa' , @level0type=N'SCHEMA',@level0name=N'guest', @level1type=N'TABLE',@level1name=N'atab', @level2type=N'COLUMN',@level2name=N'id';

    if datatype.find("(") > 0:
        if datatype.find(',') > 0:
            pattern1 = re.compile("\d+,")
            pre_str = re.sub(pattern1,'M,',datatype)
            pattern2 = re.compile(",\d+")
            data_type = re.sub(pattern2, ',N', pre_str)
            print(data_type)
        else:
            pattern = re.compile("(\w.*?)\(.*")
            s = pattern.findall(datatype)
            print('1111111')
            print(s[0])
    else:
        print('222222')
        print(datatype)

-- SQL SERVER
select value from sys.extended_properties where major_id = object_id ('Sys_User' );

CREATE TABLE auser(
	id int IDENTITY (1, 1) PRIMARY KEY,
	bid int,
	idx bigint,
	age2 integer,
	binv varbinary,
	binv2 varbinary(10),
	bit2 bit,
	uname varchar(30) default 'xxxx',
	email varchar(50) unique,
	email2 varchar,-- 
	email3 nvarchar,-- 
	email4 nvarchar(10),-- 
	sex char(10),-- 
	salarya decimal,
	salaryb numeric,
	salary decimal(10, 2),
	salaryx numeric(8,3),
	salary7 double precision,-- 
	content text,
	dtime date,
	dtime2 datetime,
	dtime3 datetime2,
	dtime4 datetimeoffset,
	etime time
);

select a.column_name,a.ordinal_position,
	a.column_default,
	a.is_nullable,
	a.data_type,
	a.character_maximum_length,
	a.numeric_precision_radix,
	a.NUMERIC_SCALE,
	a.datetime_precision,
b.constraint_name 
from (
SELECT
	column_name,
	ordinal_position,
	column_default,
	is_nullable,
	data_type,
	character_maximum_length,
	numeric_precision_radix,
	NUMERIC_SCALE,
	datetime_precision
FROM
	information_schema.COLUMNS 
WHERE
  table_schema = 'guest' and
	table_name = 'atab5'
) a left join (select column_name,constraint_name from INFORMATION_SCHEMA.KEY_COLUMN_USAGE where table_schema = 'guest' and table_name = 'atab5') b 
on a.column_name = b.column_name

-- PgSQL
CREATE TABLE auser(
	id bigserial PRIMARY KEY,
	bid bytea,
	idx int,
	id2 int2,
	id4 int4,
	id8 int8,
	age2 integer,
	age3 bigint,
	age4 inet,
	uname varchar(30) default 'xxxx',
	blv2 bool,
	blv3 boolean,
	email varchar(50) unique,
	email2 character,-- bpchar(1)
	email3 character(10),-- bpchar(10)
	email4 character varying,-- varchar
	email5 character varying(20),-- varchar(20)
	email6 bpchar,
	email7 bpchar(15),
	sex char(10),-- bpchar(10)
	salarya decimal,
	salaryb numeric,
	salary decimal(10, 2),
	salaryx numeric(8,3),
	salary2 real,-- float4
	salary7 double precision,-- float8
	content text,
	dtime date,
	etime time,
	ftime timestamp,
	ftime2 timestamp with time zone,-- timestamptz
	ftime3 timestamptz,
	inv interval
);
时间长度都忽略
serial 自增长

查看表结构：
select column_name,udt_name,ordinal_position,column_default,is_nullable,character_maximum_length,numeric_precision,numeric_scale,datetime_precision from information_schema.columns where table_schema = 'public' and table_name = 'atab6'



SELECT
	e.nspname as table_schema,
	-- A.connamespace,
	-- A.conname,
	C.relname TABLE_NAME,
	A.contype,
	b.attname
FROM
	pg_constraint A,
	pg_attribute b,
	pg_class C,
	pg_type d,
	pg_namespace e
WHERE
	A.conrelid = b.attrelid 
	AND A.connamespace = C.relnamespace 
	AND A.conrelid = C.relfilenode 
	AND A.conkey [ 1 ] = b.attnum 
	and C.oid = d.typrelid
	and d.typnamespace = e.oid
	AND b.attnum > 0 
	AND C.relname = 'auser' 
	and e.nspname = 'public'
	AND A.contype IN ('p','u')

-- MySQL
CREATE TABLE auser2  (
	id int AUTO_INCREMENT PRIMARY KEY,
	uname varchar(30) default 'xxxx',
	age int(3),
	age2 integer,
	age3 integer(5),
	blv tinyint(1),
	blv2 bool,
	email varchar(50) unique,
	sex char(10),
	salarya decimal,
	salaryb numeric,
	salary decimal(10, 2),
	salaryx numeric(8,3),
	salary2 float,
	salary3 FLOAT4,
	salary4 FLOAT8,
	salary5 FLOAT(6),
	salary6 DOUBLE,
	salary7 DOUBLE precision,
	content text,
	btext blob,
	ctime datetime,
	ctime2 datetime(0),
	ctime3 datetime(5),
	dtime date,
	etime time,
	ftime timestamp
);


查看表结构：
desc auser2;

-- Oracle

CREATE TABLE AUSER (
  id number PRIMARY KEY,
  age number(3),
  uname varchar(30) default 'xxxx',
  username nvarchar2(50),
  blval number(1),
  email varchar2(50) unique,
  salary decimal(10, 2),
  area float,
  area2 float(5),
  area3 double precision,
  content CLOB,
  content3 nclob,
  bblob blob,
  ctime date,
  dtime timestamp,
  etime timestamp(7),
  ftime timestamp(5)
);


create sequence SEQ_AUSER
minvalue 1
maxvalue 99999999999
start with 1
increment by 1
cache 20;


create or replace trigger TR_AUSER
  before insert on AUSER
  for each row
begin
  SELECT SEQ_AUSER.Nextval INTO :new.id FROM dual;
end TR_AUSER;

select aj.column_name,aj.data_type,aj.char_col_decl_length,aj.data_precision,aj.data_scale,an.CONSTRAINT_TYPE,aj.nullable,aj.data_default from (
  select column_name,data_type,char_col_decl_length,data_precision,data_scale,nullable,data_default  
from all_tab_columns a where table_name = 'AUSER' order by column_id
) aj left join (
  select a.CONSTRAINT_TYPE,b.COLUMN_NAME from user_constraints a,user_ind_columns b where a.INDEX_NAME = b.INDEX_NAME and a.OWNER = 'ROOT' AND a.table_name = 'AUSER' AND a.STATUS = 'ENABLED'
) an
on aj.COLUMN_NAME = an.COLUMN_NAME

'AutoField': 'NUMBER(11)',
'BigAutoField': 'NUMBER(19)',
'BinaryField': 'BLOB',
'BooleanField': 'NUMBER(1)',
'CharField': 'NVARCHAR2(%(max_length)s)',
'DateField': 'DATE',
'DateTimeField': 'TIMESTAMP',
'DecimalField': 'NUMBER(%(max_digits)s, %(decimal_places)s)',
'DurationField': 'INTERVAL DAY(9) TO SECOND(6)',
'FileField': 'NVARCHAR2(%(max_length)s)',
'FloatField': 'DOUBLE PRECISION',
'IntegerField': 'NUMBER(11)',
'BigIntegerField': 'NUMBER(19)',
'IPAddressField': 'VARCHAR2(15)',
'GenericIPAddressField': 'VARCHAR2(39)',
'PositiveIntegerField': 'NUMBER(11)',
'PositiveSmallIntegerField': 'NUMBER(11)',
'SmallIntegerField': 'NUMBER(11)',
'TextField': 'NCLOB',
'TimeField': 'TIMESTAMP',
'UUIDField': 'VARCHAR2(32)',

create sequence SEQ_AUSER
minvalue 1
maxvalue 99999999999
start with 1
increment by 1
cache 20;


create or replace trigger TR_AUSER
  before insert on AUSER
  for each row
begin
  SELECT SEQ_AUSER.Nextval INTO :new.id FROM dual;
end TR_AUSER;


select to_char(sysdate,'YYYYMMDDHH24MISSSSS') from dual;


查看表结构：
select aj.column_name,aj.data_type,aj.char_col_decl_length,aj.data_precision,aj.data_scale,an.CONSTRAINT_TYPE,aj.nullable,aj.data_default from (
  select column_name,data_type,char_col_decl_length,data_precision,data_scale,nullable,data_default  
from all_tab_columns a where table_name = 'AUSER' order by column_id
) aj left join (
  select a.CONSTRAINT_TYPE,b.COLUMN_NAME from user_constraints a,user_ind_columns b where a.INDEX_NAME = b.INDEX_NAME and a.OWNER = 'ROOT' AND a.table_name = 'AUSER' AND a.STATUS = 'ENABLED'
) an
on aj.COLUMN_NAME = an.COLUMN_NAME

在这里插入图片描述

["and", "or" ,"exec", "execute", "insert", "select", "delete", "update", "truncate", "drop", "or", "alter", "modify"]
pattern = re.compile(" and | or | exec | execute | insert | select | delete | update | truncate | drop | or | alter | modify ")
    t = pattern.findall(sql)
    print(t)

select * from (select top 2 a.* from (select top 4 id,uname,age from [guest].[cuser] order by 1) a order by 1 desc) b order by 1 

select top 5 * from (select row_number() over(order by id) as rownumber,* from [guest].[cuser]) temp_row where rownumber>10;

select id,username,
	case substr(version(),1,1)
		when 8 then 
			REGEXP_REPLACE(username,'tom','bbbb')
		else
			case when ((username regexp '[[:<:]]tom[[:>:]]') > 0) then replace(username,'tom','aaaa') else username end
		end 
		 as uname
from buser;

select id,username,
	case when (substr(version(),1,1) < 8) then
		case when ((username regexp '[[:<:]]tom[[:>:]]') > 0) then replace(username,'tom','aaaa') else username end
	else 
		REGEXP_REPLACE(username,'tom','bbbb')
	end as uname
from buser;

date：2019-03-27
datetime：2019-03-27 17:11:53.000
datetime2：2019-03-27 17:11:56.0000000
datetimeoffset：2019-03-27 17:11:59.0000000
time：17:12:07.0000000

SELECT * FROM [guest].[atab] where a_date = '2019-03-27';
SELECT * FROM [guest].[atab] where b_date >= '2019-03-27 17:11:53.000';
SELECT * FROM [guest].[atab] where c_date = '2019-03-27 17:11:56.0000000';
SELECT * FROM [guest].[atab] where d_date = '2019-03-27 17:11:59.0000000';
SELECT * FROM [guest].[atab] where f_date = '17:12:07.0000000';

2】字段合并
cols 传入的所有字段，字段之间使用英文逗号隔开；sep 为合并字段值时使用的分隔符；newColName 为合并后的新的字段名称

CREATE OR REPLACE FUNCTION PadpOptFunc_MergeCols(cols VARCHAR2,sep VARCHAR2,newColName VARCHAR2)
RETURN VARCHAR2
AS
	temp_cols VARCHAR2(1000) := cols;
	f_idx number;
	sep_idx number;
	col varchar2(50) := '';
	temp_sep varchar2(100) := '';
	ret VARCHAR2(4000) := '';
BEGIN
	f_idx := instr(cols, ',');
	temp_sep := '||' || '''' || sep || '''' || '||';
	IF f_idx = 0 THEN
		ret := temp_cols || temp_sep;
	ELSE
		LOOP
			sep_idx := instr(temp_cols, ',');
			IF sep_idx = 0 THEN
				ret := ret || temp_cols || temp_sep;
				EXIT;
			ELSE
				col := substr(temp_cols, 1, sep_idx - 1);
				temp_cols := substr(temp_cols, sep_idx + 1);
				ret := ret || col || temp_sep;
			END IF;
		END LOOP;
	END IF;
	
	IF ret = '' THEN
		ret := '';
	ELSE
		ret := substr(ret, 0, length(ret)-length(temp_sep));
		ret := ret || ' as ' || newColName;
	END IF;
	return ret;
END PadpOptFunc_MergeCols;

Oracle 添加变量

create function Padp_Etl_Pub_opt_Func_AddConstant(col in varchar2,val in varchar2)
return varhcar2
as
begin
	return concat(col,concat(' as ',val));
end Padp_Etl_Pub_Func_AddConstant;

1】MySQL 添加常量
传入字符名称 colName 和字段值 colVal，函数返回 'colVal' as colName

CREATE FUNCTION PadpOptFunc_AddConstant(colName VARCHAR(50),colVal VARCHAR(3900))
RETURNS VARCHAR(4000) DETERMINISTIC
RETURN (select concat('''',colVal,'''',' as ',colName));

1】PostGreSQL 添加常量
传入字符名称 colName 和字段值 colVal，函数返回 'colVal' as colName

CREATE FUNCTION PadpOptFunc_AddConstant(colName VARCHAR,colVal VARCHAR,out rs VARCHAR)
AS $$ select concat('''',$1,'''',' as ',$2)
$$ LANGUAGE SQL;

【注意】
SQL Server 创建函数或存储过程时，必须指定 架构。否则新创建的函数或存储过程可能与我们所期望的存储位置不一致。


1】添加常量
传入字符名称 colName 和字段值 colVal，函数返回 'colVal' as colName
guest 为构架名称。

CREATE FUNCTION guest.PadpOptFunc_AddConstant(@colName nvarchar(50),@colVal nvarchar(1000))
RETURNS TABLE
AS
RETURN (select '''' + @colVal + '''' + ' as ' + @colName AS col);

hive -e "show tables" | awk '{printf "export table %s to @/tmp/hive-export/%s@;\n",$1,$1}' | sed "s/@/'/g" > export.sql

hdfs dfs -get /tmp/hive-export/
scp -r hive-export/ export.sql root@targetDir
hdfs dfs -put hive-export/ /tmp/hive-export

cp export.sql import.sql
sed -i 's/export table/import table/g' import.sql
sed -i 's/ to / from /g' import.sql

hive -f import.sql 

——————————————————————————————————————————————————
(1)导出到本地文件系统
INSERT OVERWRITE LOCAL DIRECTORY '/home/hadoop/output' ROW FORMAT DELIMITED FIELDS TERMINATED by ',' select * from testA;


(2)导出到HDFS
INSERT OVERWRITE DIRECTORY '/home/hadoop/output' select * from testA;


采用hive的-e和-f参数来导出数据。
参数为： -e 的使用方式，后面接SQL语句。>>后面为输出文件路径
./hive -e "select * from testA" >> /home/hadoop/output/testA.txt

参数为： -f 的使用方式，后面接存放sql语句的文件。>>后面为输出文件路径
./hive -f /home/hadoop/output/sql.sql >> /home/hadoop/output/testB.txt


============================================================
1、HDFS上创建目录
${HADOOP_HOME}/bin/hdfs dfs -mkdir /demo1

2、上传本地文件到HDFS上
${HADOOP_HOME}/bin/hdfs dfs -put ${HADOOP_HOME}/etc/hadoop/core-site.xml /demo1

3、上传本地文件到HDFS上
${HADOOP_HOME}/bin/hdfs dfs -cat /demo1/core-site.xml

4、从HDFS上下载文件到本地
${HADOOP_HOME}/bin/hdfs dfs -get /demo1/core-site.xml

import math


# 定义一个分页的函数
def custom_paginator(current_page, total_page, max_page):
    # current_page: 表示当前页
    # total_page: 表示总页数。
    # max_page： 表示最大显示页数。

    middle = math.ceil(max_page / 2)
    # 如果总页数 小于 最大显示页数。
    # 特殊情况
    if total_page < max_page:
        start = 1
        end = total_page
    else:
        # 正常情况
        # 第一种：当前页在头部的时候。
        if current_page <= middle:
            start =1
            end = max_page
            # 第二种情况： 当前页在中间的位置
        elif (current_page > middle) and (current_page < total_page - middle):
            start = current_page - middle
            end = current_page + middle - 1
        else:
            # 第三种情况， 当前页在尾巴
            start = total_page - max_page + 1
            end = total_page

    return start, end

视图函数需要使用的工具函数：
def custom_paginator(current_page,total_page,max_page):
    if total_page <= max_page:
        start = 1
        end = total_page
    else:
        middle = math.ceil(max_page / 2)
        if current_page <= middle:
            start = 1
            end = max_page
        elif current_page < total_page - middle:
            start = current_page - middle
            end = current_page + middle - 1
        else:
            start = total_page - max_page + 1
            end = total_page
    return start,end

https://blog.csdn.net/ggz631047367/article/details/50754005

echo $[$(date +%s%N)/1000000]

https://docs.djangoproject.com/en/1.11/topics/auth/customizing/#other-authentication-sources

import time
import urllib
from importlib import import_module
from django.conf import settings
from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponseRedirect
from django.utils.cache import patch_vary_headers
from django.utils.http import cookie_date
from django.contrib.sessions.backends.base import UpdateError
from django.core.exceptions import SuspiciousOperation
from operation.settings import SSO_CONFIG, OPERATION_CONFIG
from utils.oauth import Oauth


class OauthMiddleware(MiddlewareMixin):
    """
    第一步：用户第一次访问后台时，不带cookie，所以重定向至认证服务器进行认证
    第二步：认证服务器重定向至原始访问页面，不带cookie，但带有code
    第三步：后台使用code从认证服务器获取token，获取token之后再获取用户信息，在响应中设置cookie
    第四步：用户携带cookie访问后台，这时可以直接登录
    """

    def __init__(self, get_response=None):
        self.get_response = get_response
        engine = import_module(settings.SESSION_ENGINE)
        self.SessionStore = engine.SessionStore
        self.oauth = Oauth()

    def process_request(self, request):
        session_key = request.COOKIES.get(settings.SESSION_COOKIE_NAME)
        if session_key:
            request.session = self.SessionStore(session_key)
            return None
        session = self.SessionStore(session_key)
        client_id = SSO_CONFIG.get("CLIENT_ID", "")
        host = OPERATION_CONFIG.get("HOST", "")
        port = OPERATION_CONFIG.get("PORT", "")
        redirect_uri = "http://%s:%s%s" % (host, port, request.path)
        code = request.GET.get("code", None)
        if code:
            data = self.oauth.get_token(redirect_uri, code)
            if data is not None:
                access_token = data.get("access_token", "")
                session["access_token"] = access_token
                session['redirect_uri'] = redirect_uri
                if access_token:
                    user = self.oauth.get_profile(access_token)
                request.session = session
            return None
        params = {"client_id": client_id, "response_type": "code", "redirect_uri": redirect_uri}
        params = urllib.urlencode(params)
        url = SSO_CONFIG.get("URL", "") + "/oauth/authorize?"
        return HttpResponseRedirect(url + params)

    def process_response(self, request, response):
        """
        If request.session was modified, or if the configuration is to save the
        session every time, save the changes and set a session cookie or delete
        the session cookie if the session has been emptied.
        """
        try:
            accessed = request.session.accessed
            modified = request.session.modified
            empty = request.session.is_empty()
        except AttributeError:
            pass
        else:
            # First check if we need to delete this cookie.
            # The session should be deleted only if the session is entirely empty
            if settings.SESSION_COOKIE_NAME in request.COOKIES and empty:
                response.delete_cookie(
                    settings.SESSION_COOKIE_NAME,
                    path=settings.SESSION_COOKIE_PATH,
                    domain=settings.SESSION_COOKIE_DOMAIN,
                )
            else:
                if accessed:
                    patch_vary_headers(response, ('Cookie',))
                if (modified or settings.SESSION_SAVE_EVERY_REQUEST) and not empty:
                    if request.session.get_expire_at_browser_close():
                        max_age = None
                        expires = None
                    else:
                        max_age = request.session.get_expiry_age()
                        expires_time = time.time() + max_age
                        expires = cookie_date(expires_time)
                    # Save the session data and refresh the client cookie.
                    # Skip session save for 500 responses, refs #3881.
                    if response.status_code != 500:
                        try:
                            request.session.save()
                        except UpdateError:
                            raise SuspiciousOperation(
                                "The request's session was deleted before the "
                                "request completed. The user may have logged "
                                "out in a concurrent request, for example."
                            )
                        response.set_cookie(
                            settings.SESSION_COOKIE_NAME,
                            request.session.session_key, max_age=max_age,
                            expires=expires, domain=settings.SESSION_COOKIE_DOMAIN,
                            path=settings.SESSION_COOKIE_PATH,
                            secure=settings.SESSION_COOKIE_SECURE or None,
                            httponly=settings.SESSION_COOKIE_HTTPONLY or None,
                        )
        return response

作者：nummy
链接：https://www.jianshu.com/p/1df58887466d
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

select r2.table_catalog as owner,r2.table_name,r2.column_name,r2.data_type,coalesce(r2.character_maximum_length,r2.numeric_precision,null) as data_length,r1.description as comments from 
(
SELECT
	DISTINCT
	A.attrelid,
	c.relname,
	a.attname,
	a.attnum,
	d.description
FROM
	pg_class C,
	pg_attribute A,
	pg_description d
WHERE
	C .relname = 'user'
AND d.objoid = C .oid
AND d.objoid = A .attrelid
AND d.objsubid = A .attnum
) r1,
(
select table_catalog,table_name,column_name,data_type,character_maximum_length,numeric_precision from information_schema.columns where table_name = 'user'
) r2
where (r1.relname,attname) = (r2.table_name,r2.column_name)


show grants for 'root'@'localhost';  

select user,host from mysql.user;




select CONCAT(user,'@',host) as jurl from mysql.user

show grants for (select CONCAT(user,'@',host) as jurl from mysql.user);

create user 'boss'@'localhost' IDENTIFIED by '123456';	-- boss 用户拥有查看所有数据库所有表的权限
grant select on *.* to boss@localhost;

create user 'leader'@'localhost' IDENTIFIED by '123456';	-- leader 用户拥有查看某个数据库所有表的权限
grant select on mysqldb.* to leader@localhost;

create user 'employee'@'localhost' IDENTIFIED by '123456';	-- boss 用户拥有查看具体某个表的权限
grant select on mysqldb.students to employee@localhost;


-- 1）如果根据 user 和 host 查询 mysql.user 的 Select_priv的值为 Y，则查出所有数据库的所有表 select TABLE_SCHEMA,TABLE_NAME from information_schema.TABLES
-- 2）如果上述 Select_priv的值为 N，则根据 db 和 user、host 查询 mysql.db 的 Select_priv的值，如果为 Y，则查询出指定 db 下所有的表 select TABLE_SCHEMA,TABLE_NAME from information_schema.TABLES where TABLE_SCHEMA = 'mysqldb'
-- 3）如果上述 Select_priv的值为 N，则根据 db、user、host、host 查询 mysql.table_priv 查出所有表 select t.Table_priv from tables_priv t where (t.db,user,t.host) = ('mysqldb','employee','localhost');



if EXISTS(select u.Select_priv from mysql.user u where (u.host,u.User,u.Select_priv) = ('localhost','boss','Y')) THEN
		select TABLE_SCHEMA,TABLE_NAME from information_schema.TABLES
	ELSEIF EXISTS(select d.Select_priv from mysql.db d where (d.db,d.host,d.User,d.Select_priv) = ('mysqldb','localhost','boss','Y')) THEN
		select TABLE_SCHEMA,TABLE_NAME from information_schema.TABLES where TABLE_SCHEMA = 'mysqldb'
	ELSEIF EXISTS(select t.table_name from mysql.table_priv t where (t.db,t.host,t.User) = ('mysqldb','localhost','boss')) THEN
		select t.table_name from mysql.tables_priv t where (t.db,t.host,t.User) = ('mysqldb','localhost','boss')
	ELSE
		''
	END if



select COLUMN_TYPE, substring(COLUMN_TYPE,INSTR(COLUMN_TYPE,'(')+1,INSTR(COLUMN_TYPE,')')-INSTR(COLUMN_TYPE,'(')-1)  from information_schema.columns where table_name='students';



select TABLE_SCHEMA as owner,TABLE_NAME,column_name,data_type,substring(COLUMN_TYPE,INSTR(COLUMN_TYPE,'(')+1,INSTR(COLUMN_TYPE,')')-INSTR(COLUMN_TYPE,'(')-1) as data_length,column_comment from information_schema.columns where table_name='students';



SELECT
	TABLE_SCHEMA AS OWNER,
	TABLE_NAME,
	column_name,
	data_type,
	if(data_type in('char','int','smallint','tinyint','mediumint','integer','bigint','double','float'),
		substring(
			COLUMN_TYPE,
			INSTR(COLUMN_TYPE, '(') + 1,
			INSTR(COLUMN_TYPE, ')') - INSTR(COLUMN_TYPE, '(') - 1
		),'') AS data_length,

	column_comment,COLUMN_TYPE
	
FROM
	information_schema. COLUMNS
WHERE
	table_name = 'tt';

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': '[%(levelname)s][%(asctime)s][%(filename)s][%(funcName)s][%(lineno)d]> %(message)s'
        },
        'simple': {
            'format': '[%(levelname)s]> %(message)s'
        },
    },
    'filters': {
        'require_debug_true': {
            '()': 'django.utils.log.RequireDebugTrue',
        },
    },
    'handlers': {
        'console': {
            'level': 'DEBUG',
            'filters': ['require_debug_true'],
            'class': 'logging.StreamHandler',
            'formatter': 'simple'
        },  # print any DEBUG (or higher) message
        'file_handler': {
            'level': 'INFO',
            'class': 'logging.handlers.TimedRotatingFileHandler',
            'filename': '{}/{}'.format(BASE_DIR,'padp_cloud.log'),
            'encoding': 'utf-8',
            'formatter': 'standard'
        },  # 用于文件输出
        'mail_admins': {
            'level': 'ERROR',
            'class': 'django.utils.log.AdminEmailHandler',
            'formatter': 'standard'
        },  # 会向站点管理员发送日志，可以在后台使用 admin 查看 log
    },
    'loggers': {
        'django': {
            'handlers': ['console', 'file_handler'],
            'level': 'DEBUG',
            'propagate': True,
        },
        'django.request': {
            'handlers': ['mail_admins'],
            'level': 'ERROR',
            'propagate': False,
        },
    }
}

协程

1）python3.4	asynico + yield form
	异步操作，需要在coroutine中通过yield from完成。
	
	'''
	coroutine：协程
	@asyncio.coroutine把一个 generator标记为 coroutine类型
	yield from语法可以让我们方便地调用另一个generator

	协程就是单个线程，它可以在程序内部中断，然后进入另外一个子程序，在适当的时候又回到原来的程序继续执行。
	因为协程没有锁机制，也不需要来回切换线程，所以协程执行效率非常高。
	'''
	
	import asyncio

	# IO 操作函数
	@asyncio.coroutine
	def readFile(i):
		k = 0
		with open('img.txt',mode='r',encoding='utf8') as f:
			for line in f:
				k += 1
		print('over----------k={}'.format(k+i))

	# 包含耗时的 IO 操作的函数
	@asyncio.coroutine
	def one(i):
		print('-------模拟进行 IO 操作-----------开始：{}'.format(i))
		yield from asyncio.gather(readFile(i))
		print('-------模拟进行 IO 操作-----------结束：{}'.format(i))
		return 100 + i  # 不指定 return，则返回 None

	@asyncio.coroutine
	def test(i):  # 在函数前加 async，将函数变成一个协程
		print("test_1", i)
		# r = await asyncio.sleep(2)    # asyncio.sleep(secodes)：模拟 IO 操作
		r = yield from one(i)                 # one(i)：一个耗时的 IO 操作
		print(r)
		print("test_2", i,'\n')

	loop = asyncio.get_event_loop()         # get_event_loop()：返回一个异步的循环事件
	tasks = [test(i) for i in range(5)]     # 任务列表
	loop.run_until_complete(asyncio.wait(tasks))
	loop.close()
	
	输出结果：
	test_1 3
	-------模拟进行 IO 操作-----------开始：3
	test_1 4
	-------模拟进行 IO 操作-----------开始：4
	test_1 0
	-------模拟进行 IO 操作-----------开始：0
	test_1 2
	-------模拟进行 IO 操作-----------开始：2
	test_1 1
	-------模拟进行 IO 操作-----------开始：1
		<输出到这里时会停顿一会儿，因为这时在读取文件内容>
	over----------k=1001003
		<输出到这里时会停顿一会儿，因为这时在读取文件内容>
	over----------k=1001004
		<输出到这里时会停顿一会儿，因为这时在读取文件内容>
	over----------k=1001000
		<输出到这里时会停顿一会儿，因为这时在读取文件内容>
	over----------k=1001002
		<输出到这里时会停顿一会儿，因为这时在读取文件内容>
	over----------k=1001001
	-------模拟进行 IO 操作-----------结束：3
	103
	test_2 3 

	-------模拟进行 IO 操作-----------结束：4
	104
	test_2 4 

	-------模拟进行 IO 操作-----------结束：0
	100
	test_2 0 

	-------模拟进行 IO 操作-----------结束：2
	102
	test_2 2 

	-------模拟进行 IO 操作-----------结束：1
	101
	test_2 1 
	
	
2）python3.5	asynico + await
	异步操作，需要在coroutine中通过yield from完成。
	
	import asyncio

	# IO 操作函数
	async def readFile(i):
		k = 0
		with open('img.txt',mode='r',encoding='utf8') as f:
			for line in f:
				k += 1
		print('over----------k={}'.format(k+i))

	# 包含耗时的 IO 操作的函数
	async def one(i):
		print('-------模拟进行 IO 操作-----------开始：{}'.format(i))
		await asyncio.gather(readFile(i))
		print('-------模拟进行 IO 操作-----------结束：{}'.format(i))
		return 100 + i  # 不指定 return，则返回 None

	async def test(i):  # 在函数前加 async，将函数变成一个协程
		print("test_1", i)
		# r = await asyncio.sleep(2)    # asyncio.sleep(secodes)：模拟 IO 操作
		r = await one(i)                 # one(i)：一个耗时的 IO 操作
		print(r)
		print("test_2", i,'\n')

	loop = asyncio.get_event_loop()         # get_event_loop()：返回一个异步的循环事件
	tasks = [test(i) for i in range(5)]     # 任务列表
	loop.run_until_complete(asyncio.wait(tasks))
	loop.close()
	
	执行结果：
	test_1 3
	-------模拟进行 IO 操作-----------开始：3
	test_1 4
	-------模拟进行 IO 操作-----------开始：4
	test_1 0
	-------模拟进行 IO 操作-----------开始：0
	test_1 2
	-------模拟进行 IO 操作-----------开始：2
	test_1 1
	-------模拟进行 IO 操作-----------开始：1
		<输出到这里时会停顿一会儿，因为这时在读取文件内容>
	over----------k=1001003
		<输出到这里时会停顿一会儿，因为这时在读取文件内容>
	over----------k=1001004
		<输出到这里时会停顿一会儿，因为这时在读取文件内容>
	over----------k=1001000
		<输出到这里时会停顿一会儿，因为这时在读取文件内容>
	over----------k=1001002
		<输出到这里时会停顿一会儿，因为这时在读取文件内容>
	over----------k=1001001
	-------模拟进行 IO 操作-----------结束：3
	103
	test_2 3 

	-------模拟进行 IO 操作-----------结束：4
	104
	test_2 4 

	-------模拟进行 IO 操作-----------结束：0
	100
	test_2 0 

	-------模拟进行 IO 操作-----------结束：2
	102
	test_2 2 

	-------模拟进行 IO 操作-----------结束：1
	101
	test_2 1 
	
说明：python3.4与python3.5协程实现相比，只是把yield from换成了await，@asyncio.coroutine换成了async，其余不变。


Python通过yield提供了对协程的基本支持，但是不完全。而第三方的gevent为Python提供了比较完善的协程支持。
实际代码里，我们不会用gevent.sleep()去切换协程，而是在执行到IO操作时，gevent自动切换
1）单个类协程
from gevent import monkey; monkey.patch_socket()
import gevent

def f(n):
	for i in range(n):
		print(gevent.getcurrent(), i)

g1 = gevent.spawn(f, 3)
g2 = gevent.spawn(f, 2)
g3 = gevent.spawn(f, 4)
g1.join()
g2.join()
g3.join()

执行结果：
<Greenlet "Greenlet-0" at 0x352f948: f(3)> 0
<Greenlet "Greenlet-0" at 0x352f948: f(3)> 1
<Greenlet "Greenlet-0" at 0x352f948: f(3)> 2
<Greenlet "Greenlet-1" at 0x352fa48: f(2)> 0
<Greenlet "Greenlet-1" at 0x352fa48: f(2)> 1
<Greenlet "Greenlet-2" at 0x352fb48: f(4)> 0
<Greenlet "Greenlet-2" at 0x352fb48: f(4)> 1
<Greenlet "Greenlet-2" at 0x352fb48: f(4)> 2
<Greenlet "Greenlet-2" at 0x352fb48: f(4)> 3


2）多个协程
from gevent import monkey;monkey.patch_all()
import gevent
from urllib import request

def f(url):
	print('GET: %s' % url)
	resp = request.urlopen(url)
	data = resp.read()
	print('%d bytes received from %s.' % (len(data), url))

gevent.joinall([
	gevent.spawn(f, 'https://www.python.org/'),
	gevent.spawn(f, 'https://www.yahoo.com/'),
	gevent.spawn(f, 'https://github.com/'),
])

执行结果：
GET: https://www.python.org/
GET: https://www.yahoo.com/
GET: https://github.com/
59455 bytes received from https://github.com/.
48805 bytes received from https://www.python.org/.
519342 bytes received from https://www.yahoo.com/.


3）线程池
import gevent
from gevent import monkey, pool
monkey.patch_all()
from urllib import request

urls = [
	'http://fanyi.baidu.com/',
	'https://www.yahoo.com/',
	'https://baidu.com/',
]
p = pool.Pool(10)
jobs = []

def f(url):
	print('GET: %s' % url)
	resp = request.urlopen(url)
	data = resp.read()
	print('%d bytes received from %s.' % (len(data), url))

def test(f):
	jobs = []
	for url in urls:
		jobs.append(gevent.spawn(f, url))
	return jobs

pool.joinall(test(f))

执行结果：
GET: http://fanyi.baidu.com/
GET: https://www.yahoo.com/
GET: https://baidu.com/
117909 bytes received from https://baidu.com/.
179422 bytes received from http://fanyi.baidu.com/.
533397 bytes received from https://www.yahoo.com/.

SET @ROW_NUMBER:=0; 
SET @median_group:='';

SELECT 
    median_group, AVG(height) AS median
FROM
    (SELECT 
        @ROW_NUMBER:=CASE
                WHEN @median_group = gender THEN @ROW_NUMBER + 1
                ELSE 1
            END AS count_of_group,
            @median_group:=gender AS median_group,
            gender,
            height,
            (SELECT 
                    COUNT(*)
                FROM
                    heights
                WHERE
                    a.gender = gender) AS total_of_group
    FROM
        (SELECT 
        gender, height
    FROM
        heights
    ORDER BY gender , height) AS a) AS b
WHERE
    count_of_group BETWEEN total_of_group / 2.0 AND total_of_group / 2.0 + 1
GROUP BY median_group

select AVG(DISTINCT income)
from (
select T1.income from graduates T1,graduates T2
group by T1.income
having sum(case when T2.income >= T1.income then 1 else 0 end) >= count(*)/2
and sum(case when T2.income <= T1.income then 1 else 0 end) >= count(*)/2
) tmp;

CREATE FUNCTION dbo.RegexReplace  
(  
    @string VARCHAR(MAX),   --被替换的字符串  
    @pattern VARCHAR(255),  --替换模板  
    @replacestr VARCHAR(255),   --替换后的字符串  
    @IgnoreCase INT = 0 --0区分大小写 1不区分大小写  
)  
RETURNS VARCHAR(8000)  
AS   
BEGIN  
    DECLARE @objRegex INT, @retstr VARCHAR(8000)  
    --创建对象  
    EXEC sp_OACreate 'VBScript.RegExp', @objRegex OUT  
    --设置属性  
    EXEC sp_OASetProperty @objRegex, 'Pattern', @pattern  
    EXEC sp_OASetProperty @objRegex, 'IgnoreCase', @IgnoreCase  
    EXEC sp_OASetProperty @objRegex, 'Global', 1  
    --执行  
    EXEC sp_OAMethod @objRegex, 'Replace', @retstr OUT, @string, @replacestr  
    --释放  
    EXECUTE sp_OADestroy @objRegex  
    RETURN @retstr  
END  
GO  
--保证正常运行的话，需要将Ole Automation Procedures选项置为1    
EXEC sp_configure 'show advanced options', 1    
RECONFIGURE WITH OVERRIDE   
EXEC sp_configure 'Ole Automation Procedures', 1    
RECONFIGURE WITH OVERRIDE

select
 字段名=rtrim(b.name),
 主键=case when h.id is not null then 'PK' else '' end,
 字段类型=type_name(b.xusertype)+case when b.colstat&1=1 then '[ID(' + convert(varchar, ident_seed(a.name))+','+convert(varchar,ident_incr(a.name))+')]' else '' end,
 长度=b.length, 
 允许空=case b.isnullable when 0 then 'N' else 'Y' end, 
 默认值=isnull(e.text, ''),
 字段说明=isnull(c.value, '')
from sysobjects a, syscolumns b
left join sysproperties c on b.id = c.id and b.colid = c.smallid
left join syscomments e on b.cdefault = e.id
left join (select g.id, g.colid from sysindexes f, sysindexkeys g where (f.id=g.id) and (f.indid=g.indid) and (f.indid>0) and (f.indid<255) and (f.status&2048)<>0) h on (b.id=h.id) and (b.colid=h.colid)
where (a.id=b.id) and (a.id=object_id('要查询的表')) 
order by b.colid

class Singleton():
    _singleton = None

    def __new__(cls, *args, **kwargs):
        if not cls._singleton:
            cls._singleton = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._singleton

from Cryptodome.Cipher import AES
from binascii import b2a_hex, a2b_hex

class prpcrypt():
    def __init__(self, key,length = 16):
        self.key = key
        self.length = length
        self.mode = AES.MODE_ECB
        self.cryptor = AES.new(self.pad_key(self.key).encode(), self.mode)

    # 加密函数，如果text不是16的倍数【加密文本text必须为16的倍数！】，那就补足为16的倍数
    # 加密内容需要长达16位字符，所以进行空格拼接
    def pad(self,text):
        while len(text) % self.length != 0:
            text += ' '
        return text

    # 加密密钥需要长达16位字符，所以进行空格拼接
    def pad_key(self,key):
        while len(key) % self.length != 0:
            key += ' '
        return key

    def encrypt(self, text):

        # 这里密钥key 长度必须为16（AES-128）、24（AES-192）、或32（AES-256）Bytes 长度.目前AES-128足够用
        # 加密的字符需要转换为bytes
        # print(self.pad(text))
        self.ciphertext = self.cryptor.encrypt(self.pad(text).encode())
        # 因为AES加密时候得到的字符串不一定是ascii字符集的，输出到终端或者保存时候可能存在问题
        # 所以这里统一把加密后的字符串转化为16进制字符串
        return b2a_hex(self.ciphertext)

        # 解密后，去掉补足的空格用strip() 去掉

    def decrypt(self, text):
        plain_text = self.cryptor.decrypt(a2b_hex(text)).decode()
        return plain_text.rstrip(' ')


if __name__ == '__main__':
    pc = prpcrypt('abcdef')  # 初始化密钥
    # e = pc.encrypt("0123456789ABCDEF")
    # d = pc.decrypt(e)
    # print(e, d)
    # e = pc.encrypt("00000000000000000000000000")
    # d = pc.decrypt(e)
    # print(e, d)
    e = pc.decrypt(b'011704c9ca48ae83fe63c9b245a48cde')
    print(e)

建立动态路由需要用到的文件是：D
A. /etc/resolv.conf
B. /etc/hosts
C. /etc/HOSTNAME
D. /etc/gateways

当内网内没有建立dns服务器时，又不想用IP访问网站，则可以通过哪个配置文件进行配置：C
A. network
B. hostname
C. hosts
D. sysconfig

以下哪些属于 Nginx 负载均衡策略：ABCD
A. weight
B. ip_hash
C. 轮询
D. fair

Nginx 对后端服务的健康检查可以通过：ABC
A. ngx_http_proxy_module
B. ngx_http_upstream_module
C. nginx_upstream_check_module
D. ngx_http_upstream_check_module

Linux 系统中，要在 /huser 这个空文件夹下创建子文件夹 clib，并在 clib 下创建子文件夹 libs，可通过哪个命令：D
A. mkdir /huser/clib/libs
B. mkdir /huser/clib/libs/
C. mkdir -r /huser/clib/libs
D. mkdir -p /huser/clib/libs

下列选项中属于 SQL 语言数据定义关键字的是：A
A. Create
B. Delete
C. Update
D. Select

下列关于数据库知识表述正确的是：A
A. 主键只能有一个
B. 外键只能有一个
C. 唯一键只能有一个
D. 索引只能有一个

要删除表数据且重置自增主键的方法是：B
A. delete
B. truncate
C. drop
D. 以上都可以

Redis 支持哪些数据类型：ABC
A. String
B. Hash
C. List
D. Dict

Redis 设置 name 的有效期为 60s：C
A. set name 60
B. set name 60000
C. EXPIRE name 60
D. EXPIRE name 60000

对于 4核8g 配置，Nignx 可以配置的最大进程数是：C
A. 1
B. 2
C. 4
D. 8

sonehb

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
0001-临时

select r2.table_catalog as owner,r2.table_name,r2.column_name,r2.data_type,coalesce(character_maximum_length,numerric_precision,'') as data_length,r1.description as comments from (SELECT DISTINC...
复制链接

扫一扫