MySql、PostgreSql、SqlServer三種數據庫的造數存儲過程實例

主要實例：把臨時表tmp_table數據插入到目標表target_table

 

一、MySql造數存儲過程實例

mysql造數

 

-- 第一步，創建臨時表
CREATE TEMPORARY TABLE
IF NOT EXISTS tmp_table (
    `id` VARCHAR (64) NOT NULL,
    `second_id` VARCHAR (64) NOT NULL,
    `total_amount` DOUBLE (18, 2) DEFAULT NULL,
    `total_day` INT (11) DEFAULT NULL,
    `create_time` datetime NOT NULL,
    `edit_time` datetime DEFAULT NULL,
    `editor` VARCHAR (50) DEFAULT NULL,
    `status` INT (11) NOT NULL DEFAULT '0'
) DEFAULT CHARSET = utf8mb4;

-- 第二步，使用前先清空臨時表    
TRUNCATE TABLE tmp_table;

-- 第三步，定義存儲過程
-- 生成5-10位隨機正整數ceiling(5 - 1 + rand() *(10 -(5 - 1)))
-- 生成5-7位隨機正整數 FLOOR(5 + RAND() *(7 + 1 - 5))

#定義存儲過程
delimiter ##num_limit 要插入數據的數量,rand_limit 最大隨機的數值 
DROP PROCEDURE
IF EXISTS insert_test_val ; 
CREATE PROCEDURE insert_test_val (IN num_limit INT)
BEGIN
DECLARE i INT DEFAULT 1; 
DECLARE id VARCHAR (64) DEFAULT 1;
DECLARE second_id VARCHAR (64) DEFAULT 1;
            WHILE i <= num_limit DO
                INSERT INTO testdb.tmp_table (
                    `id`,
                    `second_id`,
                    `total_amount`,
                    `total_day`,
                    `create_time`,
                    `edit_time`,
                    `editor`,
                    `status`
                )
            VALUES
                (
                    id,
                    second_id,
                    ceiling(5 - 1 + rand() *(10 -(5 - 1))),
                    FLOOR(5 + RAND() *(7 + 1 - 5)),
                    SYSDATE(),
                    SYSDATE(),
                    'mysql存儲過程',
                    '0'
                ) ;
            SET id = id + 1 ;
            SET second_id = second_id + 1 ;
            SET i = i + 1 ;
            END
            WHILE ;
END 

-- 第四步，調用存儲過程，插入1萬條數據
#調用存儲過程
CALL insert_test_val (10000) ; 

-- 第五步，可跳過
#查看臨時表（檢查存儲過程是否生成數據）
SELECT * FROM tmp_table ; 

-- 第六步，插入到目標表
INSERT INTO `testdb`.`target_table` (`id`,`second_id`,`total_amount`,`total_day`,`create_time`,`edit_time`,`editor`,`status`) SELECT * FROM tmp_table ; 

-- 第七步，刪除存儲過程生成的數據（若不需要刪除則跳過）
DELETE FROM target_table WHERE id = second_id ; 

-- 第八步，刪除存儲過程（若不需要刪除則跳過）
DROP PROCEDURE IF EXISTS insert_test_val ;

 

 

二、PostgreSql造數存儲過程實例

postgresql造數

-- 第一步，創建臨時表
CREATE TEMPORARY TABLE
IF NOT EXISTS tmp_table2 (
    "encryptionphone_text" VARCHAR (32) COLLATE "default",
    "user_id" int4,
    "target_code" VARCHAR (32) COLLATE "default",
    "target_time" TIMESTAMP (6),
    "creator" VARCHAR (128) COLLATE "default",
    "create_time" TIMESTAMP (6) DEFAULT now(),
    "editor" VARCHAR (128) COLLATE "default",
    "edit_time" TIMESTAMP (6) DEFAULT now(),
    "status" bool DEFAULT TRUE
);

-- 第二步，使用前先清空臨時表
TRUNCATE TABLE tmp_table2;

-- 第三步，定義存儲過程，num_limit 要插入數據的數量
DROP FUNCTION
IF EXISTS insert_test2();

CREATE OR REPLACE FUNCTION insert_test2(IN num_limit INT) RETURNS void AS 
$$
DECLARE    i INT DEFAULT 1;
DECLARE    encryptionphone_text INT DEFAULT 1;
DECLARE  initDate INT DEFAULT 1565332582;
DECLARE  initDateStr timestamp;

BEGIN

WHILE i <= num_limit LOOP

initDateStr := to_timestamp(initDate+60*60*24*1+encryptionphone_text%(60*60*24*17));

INSERT INTO tmp_table2 (
    "encryptionphone_text",
    "user_id",
    "target_code",
    "target_time",
    "creator",
    "create_time",
    "editor",
    "edit_time",
    "status"
)
VALUES
    (
        '1a2b3c4d5e6f7g8h9i' || CAST (@encryptionphone_text AS VARCHAR (32)),
        i,
        '9876543210',
        initDateStr,
        'insert_test2函數所造',
        now(),
        NULL,
        now(),
        't'
    );
encryptionphone_text := encryptionphone_text + 1;
i := i + 1;
END LOOP;

END; 
$$ LANGUAGE plpgsql;

-- 第四步，調用存儲過程，插入1萬條數據
SELECT insert_test2(10000);
-- 第五步，查詢臨時表（可跳過）
select * from tmp_table2;

-- 第六步，插入到目標表
INSERT INTO target_table("encryptionphone_text", "user_id", "target_code", "target_time", "creator", "create_time", "editor", "edit_time", "status") 
SELECT * from tmp_table2;

-- 第七步，檢查插入數據是否正確
SELECT count(1) from target_table;

-- 第八步，刪除存儲過程（若不需要刪除則跳過）
DROP FUNCTION insert_test2(IN num_limit INT);

 

除了上面格式的存儲過程，可在轉化數據后再插入數據，例子如下：

-- 第一步，創建臨時表
CREATE TEMPORARY TABLE if not exists tmp_table
 ("phone_md5" varchar(32) COLLATE "default");

-- 第二步，使用前先清空臨時表
TRUNCATE TABLE tmp_table;

-- 第三步，定義存儲過程，num_limit 要插入數據的數量
DROP FUNCTION
IF EXISTS insert_test1();
CREATE OR REPLACE FUNCTION insert_test1(IN num_limit INT) RETURNS void AS 
$$
DECLARE    i INT DEFAULT 1390000000;
BEGIN
WHILE i <= num_limit LOOP
INSERT INTO tmp_table("phone_md5") 
VALUES (i);
i := i + 1;
END LOOP;
END; 
$$ LANGUAGE plpgsql;

-- 第四步，調用存儲過程，插入1萬條數據
SELECT insert_test1(1390010000);
-- 第五步，查詢臨時表（可跳過）
select * from tmp_table;

-- 第六步，插入到目標表
INSERT INTO encryptionphone_list("phone_md5") 
SELECT md5(phone_md5) from tmp_table;

-- 第七步，檢查插入數據是否正確
SELECT count(1) from encryptionphone_list;

-- 第八步，刪除存儲過程
DROP FUNCTION insert_test1(IN num_limit INT);

 

三、SqlServer造數存儲過程實例

sqlserver造數

 

-- 第一步，刪掉##aa緩存表
drop table ##aa;

-- 第二步，定義緩存表##aa
if OBJECT_ID('tempdb..##aa') is not null
drop table ##aa
CREATE TABLE ##aa(
[phone] varchar(32)   NULL ,
[name] varchar(32)   NULL ,
[CreateDate] datetime NULL DEFAULT (getdate()) ,
[EditDate] datetime NULL DEFAULT (getdate()) 
)

-- 第三步，清空緩存表
TRUNCATE TABLE ##aa;
    
-- 第四步，定義存儲過程，並執行
DECLARE @i INT
DECLARE @s VARCHAR(20)
declare @phone int
SET @i=1
set @phone=10000000
WHILE @i<=10000000
BEGIN
SELECT @s=CAST(@i as VARCHAR(20))
insert into ##aa
select '131'+CAST(@phone as VARCHAR(20)), '簡單存儲生成'+i, GETDATE(), GETDATE()
set @phone=@phone+1
set @i=@i+1
end

-- 第五步，把緩存表數據插入到目標表
insert into target_table( [phone], [name], [CreateDate], [EditDate])
select * from ##aa;

-- 第六步，檢查目標表數據
select * from target_table;