PostgreSQL & Oracle - 2 OLTP "update/select based primary key" & insert

最新推荐文章于 2024-10-16 11:14:53 发布
最新推荐文章于 2024-10-16 11:14:53 发布
阅读量556 收藏
点赞数
分类专栏： 转载 数据库管理 文章标签： postgresql 数据库 oracle

Postgres2015全国用户大会将于11月20至21日在北京丽亭华苑酒店召开。本次大会嘉宾阵容强大，国内顶级PostgreSQL数据库专家将悉数到场，并特邀欧洲、俄罗斯、日本、美国等国家和地区的数据库方面专家助阵:

  • Postgres-XC项目的发起人铃木市一(SUZUKI Koichi)
  • Postgres-XL的项目发起人Mason Sharp
  • pgpool的作者石井达夫(Tatsuo Ishii)
  • PG-Strom的作者海外浩平(Kaigai Kohei)
  • Greenplum研发总监姚延栋
  • 周正中(德哥), PostgreSQL中国用户会创始人之一
  • 汪洋，平安科技数据库技术部经理
  • ……
 
  • 2015年度PG大象会报名地址：http://postgres2015.eventdove.com/
  • PostgreSQL中国社区： http://postgres.cn/
  • PostgreSQL专业1群： 3336901（已满）
  • PostgreSQL专业2群： 100910388
  • PostgreSQL专业3群： 150657323



本文主要是针对Oracle的测试， PostgreSQL的测试和测试结果请参考上一篇：

Oracle版本为12c。硬件和软件环境与上一篇测试PostgreSQL的保持一致，同一台主机，测试时关闭其他任何有干扰的服务和软件。
调整Oracle参数，创建测试表，生成测试数据： 

  
  

   
   SQL> create tablespace tbs_digoal datafile '/data01/oradata/tbs_digoal' size 30G autoextend off;
  
  

  
  

   
   SQL> create tablespace tbs_digoal_idx datafile '/data02/oradata/tbs_digoal_idx' size 30G autoextend off;
  
  

  
  

   
   

  
  

  
  

   
   SQL> create user digoal identified by digoal default tablespace tbs_digoal;
  
  

  
  

   
   SQL> grant resource,connect,dba to digoal;
  
  

  
  

   
   SQL> grant unlimited tablespace to digoal;
  
  

  
  

   
   

  
  

  
  

   
   SQL> alter system set processes=2000 scope=spfile;
  
  

  
  

   
   SQL> alter system set SGA_TARGET=24G scope=spfile;
  
  

  
  

   
   SQL> alter system set PGA_AGGREGATE_TARGET=1G scope=spfile;
  
  

  
  

   
   SQL> alter system set db_keep_cache_size=10G scope=spfile;
  
  

  
  

   
   SQL> alter system set CURSOR_SHARING=force scope=spfile;
  
  

  
  

   
   SQL> alter system set commit_logging='batch' scope=spfile;  
  
  

  
  

   
   SQL> alter system set commit_write='nowait' scope=spfile;
  
  

  
  

   
   

  
  

  
  

   
   SQL> shutdown immediate
  
  

  
  

   
   SQL> startup
  
  

  
  

   
   

  
  

  
  

   
   SQL> conn digoal/digoal
  
  

  
  

   
   SQL> create table tbl (id int,info varchar2(256),crt_time date) tablespace tbs_digoal;

插入测试数据： 

  
  

   
   declare   
  
  

  
  

   
   id int := 1; 
  
  

  
  

   
   begin   
  
  

  
  

   
   loop   
  
  

  
  

   
   exit when id>50000000; 
  
  

  
  

   
   insert into digoal.tbl nologging select id,sysdate,sysdate from dual;
  
  

  
  

   
   id := id+1;
  
  

  
  

   
   end loop; 
  
  

  
  

   
   commit;
  
  

  
  

   
   end; 
  
  

  
  

   
   /
  
  

  
  

   
   

  
  

  
  

   
   -- 或
  
  

  
  

   
    
  
  

  
  

   
   declare  
  
  

  
  

   
   maxrecords constant int := 50000000; 
  
  

  
  

   
   begin 
  
  

  
  

   
   for id in 1..maxrecords loop 
  
  

  
  

   
   insert into digoal.tbl nologging select id,sysdate,sysdate from dual;
  
  

  
  

   
   end loop; 
  
  

  
  

   
   dbms_output.put_line('成功导入数据！'); 
  
  

  
  

   
   commit; 
  
  

  
  

   
   end; 
  
  

  
  

   
   /
  
  

  
  

   
   

  
  

  
  

   
   -- 或
  
  

  
  

   
   SQL> insert into digoal.tbl nologging select rownum,sysdate,sysdate from dual connect by level <=50000000;

创建主键，将数据加载到内存。 

  
  

   
   SQL> alter table digoal.tbl add constraint tbl_pkey primary key(id) using index tablespace tbs_digoal_idx;
  
  

  
  

   
   SQL> alter table digoal.tbl storage (buffer_pool KEEP);
  
  

  
  

   
   SQL> alter index digoal.tbl_pkey storage (buffer_pool KEEP);

修改profile 

  
  

   
   # vi /etc/profile
  
  

  
  

   
   

    
    export ORACLE_BASE=/opt/oracle/product
   
   

   
   

    
    export ORACLE_HOME=$ORACLE_BASE/12.0.2/db_1
   
   

   
   

    
    export LD_LIBRARY_PATH=$ORACLE_HOME/lib:$LD_LIBRARY_PATH
   
   

   
   

    
    export PATH=$ORACLE_HOME/bin:$PATH
   
   

  
  

  
  

   
   

  
  

  
  

   
   # . /etc/profile

安装python oracle驱动 

  
  

   
   # wget https://pypi.python.org/packages/source/c/cx_Oracle/cx_Oracle-5.1.3.tar.gz#md5=cd6ff16559cbc9c20087ec812c7092ab
  
  

  
  

   
   # tar -zxvf cx_Oracle-5.1.3.tar.gz
  
  

  
  

   
   # cd cx_Oracle-5.1.3
  
  

  
  

   
   # python setup.py install

python测试脚本： 

  
  

   
   # vi test.py
import threading
import time
import cx_Oracle
import random

dsn=cx_Oracle.makedsn('127.0.0.1', 1521, 'oradb')

xs=12000
tps=dict()

class n_t(threading.Thread):   # The timer class is derived from the class threading.Thread
  def __init__(self, num):
    threading.Thread.__init__(self)
    self.thread_num = num

  def run(self): #Overwrite run() method, put what you want the thread do here
    db=cx_Oracle.connect('digoal','digoal',dsn)
    db.autocommit=1
    cur=db.cursor()
    pre=cur.prepare('update /*SQL' + str(self.thread_num) + '*/ tbl set info=sysdate,crt_time=sysdate where id=:id')

    tps[self.thread_num] = dict()

    f = open("/tmp/oracle_test." + str(self.thread_num), "w")

    for x in range(1,3001):
      start_t = time.time()
      for i in range(0,xs):
        cur.execute(pre,{'id':random.randrange(1,50000000)})    
      stop_t = time.time()
      tps[self.thread_num][x] = round(xs/(stop_t-start_t),2)
      res = "Round: " + str(x) + " TID: " + str(self.thread_num) + " Sec: " + str(round((stop_t-start_t),2)) + " tps: " + str(tps[self.thread_num][x])
      print >> f, res
      f.flush()

    f.close()

def test():
  t_names = []
  for i in xrange(0,26):
    t_names.append(n_t(i))

  for t in t_names:
    t.start()
  
  return

if __name__ == '__main__':
  test()

更新(26 conn)测试： 

  
  

   
   # nohup python ./test.py >/dev/null 2>&1 &
测试结果，约10秒输出一次tps： 

  
  

   
   # less /tmp/oracle_test.22
  
  

  
  

   
   

    
    Round: 1 TID: 22 Sec: 11.46 tps: 1187.12
   
   

   
   

    
    Round: 2 TID: 22 Sec: 11.34 tps: 1198.65
   
   

  
  

  
  

   
   .....
其他线程结果略。

测试结果合并： 

  
  

   
   

    
    # vi tps.py
   
   

   
   

    
    import fileinput
   
   

   
   

    
    

   
   

   
   

    
    file = dict()
   
   

   
   

    
    line = dict()
   
   

   
   

    
    tps=0
   
   

   
   

    
    

   
   

   
   

    
    for i in xrange(0,26):
   
   

   
   

    
      file[i] = open("/tmp/oracle_test." + str(i))
   
   

   
   

    
     
   
   

   
   

    
    while 1:
   
   

   
   

    
        for i in xrange(0,26):
   
   

   
   

    
          line[i] = file[i].readline().split(" ",8)[7]
   
   

   
   

    
          tps = tps + float(line[i])
   
   

   
   

    
    

   
   

   
   

    
        print(str(tps))
   
   

   
   

    
        tps=0
   
   

   
   

    
    

   
   

   
   

    
        if not line[0]:
   
   

   
   

    
          break
   
   

   
   

    
          
   
   

   
   

    
    for i in xrange(0,26):
   
   

   
   

    
      file[i].close()
   
   

  
  

  
  

   
   

  
  

  
  

   
   # python tps.py
  
  

  
  

   
   

    
    33792.57
   
   

   
   

    
    29093.92
   
   

   
   

    
    33370.67
   
   

   
   

    
    33768.3
   
   

   
   

    
    33750.5
   
   

   
   

    
    33458.86
   
   

   
   

    
    30580.32
   
   

   
   

    
    33369.79
   
   

  
  

  
  

   
   ......
图：
PostgreSQL VS Oracle - 2 OLTP update/select based primary key insert - 德哥@Digoal - PostgreSQL research
Oracle UPDATE TPS集中在32000到33000，比较平顺。

查询(36 conn)测试：
测试脚本： 

  
  

   
   # vi test.py
import threading
import time
import cx_Oracle
import random

dsn=cx_Oracle.makedsn('127.0.0.1', 1521, 'oradb')

xs=12000
tps=dict()

class n_t(threading.Thread):   # The timer class is derived from the class threading.Thread
  def __init__(self, num):
    threading.Thread.__init__(self)
    self.thread_num = num

  def run(self): #Overwrite run() method, put what you want the thread do here
    db=cx_Oracle.connect('digoal','digoal',dsn)
    db.autocommit=1
    cur=db.cursor()
    pre=cur.prepare('select /*SQL' + str(self.thread_num) + '*/ * from tbl where id=:id')

    tps[self.thread_num] = dict()

    f = open("/tmp/oracle_test." + str(self.thread_num), "w")

    for x in range(1,3001):
      start_t = time.time()
      for i in range(0,xs):
        cur.execute(pre,{'id':random.randrange(1,50000000)})    
      stop_t = time.time()
      tps[self.thread_num][x] = round(xs/(stop_t-start_t),2)
      res = "Round: " + str(x) + " TID: " + str(self.thread_num) + " Sec: " + str(round((stop_t-start_t),2)) + " tps: " + str(tps[self.thread_num][x])
      print >> f, res
      f.flush()

    f.close()

def test():
  t_names = []
  for i in xrange(0,36):
    t_names.append(n_t(i))

  for t in t_names:
    t.start()
  
  return

if __name__ == '__main__':
  test()
测试结果： 

  
  

   
   

    
    # less oracle_test.0
   
   

   
   

    
    Round: 1 TID: 0 Sec: 13.37 tps: 897.85
   
   

   
   

    
    Round: 2 TID: 0 Sec: 11.72 tps: 1023.83
   
   

   
   

    
    Round: 3 TID: 0 Sec: 11.89 tps: 1009.26
   
   

   
   

    
    Round: 4 TID: 0 Sec: 11.82 tps: 1015.2
   
   

   
   

    
    Round: 5 TID: 0 Sec: 11.84 tps: 1013.37
   
   

   
   

    
    Round: 6 TID: 0 Sec: 11.91 tps: 1007.87
   
   

   
   

    
    Round: 7 TID: 0 Sec: 11.97 tps: 1002.33
   
   

   
   

    
    Round: 8 TID: 0 Sec: 11.96 tps: 1003.0
   
   

   
   

    
    Round: 9 TID: 0 Sec: 11.92 tps: 1007.11
   
   

   
   

    
    Round: 10 TID: 0 Sec: 11.75 tps: 1020.97
   
   

   
   

    
    Round: 11 TID: 0 Sec: 11.75 tps: 1021.17
   
   

   
   

    
    Round: 12 TID: 0 Sec: 11.95 tps: 1004.07
   
   

   
   

    
    Round: 13 TID: 0 Sec: 11.81 tps: 1015.96
   
   

  
  

  
  

   
   ......
合并结果： 

  
  

   
   

    
    36637.71
   
   

   
   

    
    36436.34
   
   

   
   

    
    36512.47
   
   

   
   

    
    36614.69
   
   

   
   

    
    36585.26
   
   

   
   

    
    36553.55
   
   

   
   

    
    36578.89
   
   

   
   

    
    36540.29
   
   

   
   

    
    36483.53
   
   

   
   

    
    36594.29
   
   

   
   

    
    36438.53
   
   

   
   

    
    36518.64
   
   

   
   

    
    36480.38
   
   

  
  

  
  

   
   ......
图：
PostgreSQL VS Oracle - 2 OLTP update/select based primary key insert - 德哥@Digoal - PostgreSQL research

插入(20 conn)测试： 

  
  

   
   

    
    SQL> truncate table digoal.tbl;
   
   

   
   

    
    SQL> create sequence digoal.seq cache 12000;
   
   

  
  

  
  

   
   

    
    SQL> alter table digoal.tbl modify crt_time default sysdate;
   
   

   
   

    
    SQL> alter table digoal.tbl modify info default sysdate;
   
   

  
  

  
  

   
   SQL> alter table digoal.tbl storage (buffer_pool default);
SQL> alter index digoal.tbl_pkey storage (buffer_pool default);
测试脚本： 

  
  

   
   # vi test.py
  
  

  
  

   
   import threading
  
  

  
  

   
   import time
  
  

  
  

   
   import cx_Oracle
  
  

  
  

   
   import random
  
  

  
  

   
   

  
  

  
  

   
   dsn=cx_Oracle.makedsn('127.0.0.1', 1521, 'oradb')
  
  

  
  

   
   

  
  

  
  

   
   xs=12000
  
  

  
  

   
   tps=dict()
  
  

  
  

   
   

  
  

  
  

   
   class n_t(threading.Thread):   # The timer class is derived from the class threading.Thread
  
  

  
  

   
     def __init__(self, num):
  
  

  
  

   
       threading.Thread.__init__(self)
  
  

  
  

   
       self.thread_num = num
  
  

  
  

   
   

  
  

  
  

   
     def run(self): #Overwrite run() method, put what you want the thread do here
  
  

  
  

   
       db=cx_Oracle.connect('digoal','digoal',dsn)
  
  

  
  

   
       db.autocommit=1
  
  

  
  

   
       cur=db.cursor()
  
  

  
  

   
       pre=cur.prepare('insert /*SQL' + str(self.thread_num) +'*/ into tbl (id) values(seq.nextval)')
  
  

  
  

   
   

  
  

  
  

   
       tps[self.thread_num] = dict()
  
  

  
  

   
   

  
  

  
  

   
       f = open("/tmp/oracle_test." + str(self.thread_num), "w")
  
  

  
  

   
   

  
  

  
  

   
       for x in range(1,3001):
  
  

  
  

   
         start_t = time.time()
  
  

  
  

   
         for i in range(0,xs):
  
  

  
  

   
           cur.execute(pre)    
  
  

  
  

   
         stop_t = time.time()
  
  

  
  

   
         tps[self.thread_num][x] = round(xs/(stop_t-start_t),2)
  
  

  
  

   
         res = "Round: " + str(x) + " TID: " + str(self.thread_num) + " Sec: " + str(round((stop_t-start_t),2)) + " tps: " + str(tps[self.thread_num][x])
  
  

  
  

   
         print >> f, res
  
  

  
  

   
         f.flush()
  
  

  
  

   
   

  
  

  
  

   
       f.close()
  
  

  
  

   
   

  
  

  
  

   
   def test():
  
  

  
  

   
     t_names = []
  
  

  
  

   
     for i in xrange(0,20):
  
  

  
  

   
       t_names.append(n_t(i))
  
  

  
  

   
   

  
  

  
  

   
     for t in t_names:
  
  

  
  

   
       t.start()
  
  

  
  

   
     
  
  

  
  

   
     return
  
  

  
  

   
   

  
  

  
  

   
   if __name__ == '__main__':
  
  

  
  

   
     test()
测试结果： 

  
  

   
   

    
    # less oracle_test.19
   
   

   
   

    
    Round: 1 TID: 19 Sec: 22.98 tps: 522.25
   
   

   
   

    
    Round: 2 TID: 19 Sec: 27.12 tps: 442.54
   
   

   
   

    
    Round: 3 TID: 19 Sec: 23.8 tps: 504.2
   
   

   
   

    
    Round: 4 TID: 19 Sec: 26.47 tps: 453.35
   
   

   
   

    
    Round: 5 TID: 19 Sec: 23.63 tps: 507.83
   
   

   
   

    
    Round: 6 TID: 19 Sec: 23.78 tps: 504.72
   
   

   
   

    
    Round: 7 TID: 19 Sec: 26.02 tps: 461.13
   
   

   
   

    
    Round: 8 TID: 19 Sec: 23.9 tps: 502.02
   
   

   
   

    
    Round: 9 TID: 19 Sec: 26.22 tps: 457.67
   
   

   
   

    
    Round: 10 TID: 19 Sec: 23.48 tps: 511.14
   
   

   
   

    
    Round: 11 TID: 19 Sec: 26.89 tps: 446.31
   
   

   
   

    
    Round: 12 TID: 19 Sec: 22.46 tps: 534.37
   
   

  
  

  
  

   
   ......
合并结果： 

  
  

   
   

    
    10195.18
   
   

   
   

    
    8863.84
   
   

   
   

    
    10067.91
   
   

   
   

    
    9167.06
   
   

   
   

    
    9753.85
   
   

   
   

    
    10024.51
   
   

   
   

    
    9028.92
   
   

   
   

    
    10006.42
   
   

   
   

    
    8869.49
   
   

   
   

    
    10251.39
   
   

   
   

    
    9202.53
   
   

   
   

    
    10048.2
   
   

   
   

    
    10062.34
   
   

  
  

  
  

   
   ......
图：
PostgreSQL VS Oracle - 2 OLTP update/select based primary key insert - 德哥@Digoal - PostgreSQL research
Oracle插入时需先写UNDO,再写redo,所以比较慢.

[其他]
1. 一开始测试脚本报错， ORA-24550  KPEDBG_HDL_PUSH_FCPTRMAX。
解决办法 ：  

  
  

   
   # cd /opt/oracle/product/12.0.2/db_1/network/admin/
  
  

  
  

   
   # cp samples/sqlnet.ora ./
  
  

  
  

   
   # vi sqlnet.ora
  
  

  
  

   
   追加 : 
  
  

  
  

   
   DIAG_ADR_ENABLED=FALSE
  
  

  
  

   
   DIAG_SIGHANDLER_ENABLED=FALSE
  
  

  
  

   
   DIAG_DDE_ENABLED=FALSE
2. 测试时遇到过大量的CURSOR pin S的等待事件，通过添加注释，改写SQL解决。
例如： 

  
  

   
       pre=cur.prepare('insert /*SQL' + str(self.thread_num) +'*/ into tbl (id) values(seq.nextval)')
[参考]
Postgresql中国用户会
关注
专栏目录
NOLOGGING的正确用法
luckyman100的专栏
06-11 1万+
今天在看以前一些工作文档，发现有些DML脚本，用到了nologging的hint，即/*+NOLOGGING*/，这样写到底能不能减少日志量了？？带着疑问，我做了以下测试： 1. 直接update，看redo量 SQL> create table a as select * from dba_objects; Table created. SQL> set autotrace tr
linux postgresql默认安装目录,postgresql - 三种安装方式(示例代码)
weixin_30240263的博客
05-01 5621
最近接触了postgresql的安装，和大家分享一下。一、简 介PostgreSQL 是一种非常复杂的对象-关系型数据库管理系统(ORDBMS)，也是目前功能最强大，特性最丰富和最复杂的自由软件数据库系统。有些特性甚至连商业数据库都不具备。这个起源于伯克利(BSD)的数据库研究计划目前已经衍生成一项国际开发项目，并且有非常广泛的用户。二、三种安装过程A. RPM包安装1. 检查PostgreSQL...
Postgre中的 select for update 和 select for update nowait
sun0322
09-16 8420
使用 select for update时，但数据被锁住时， 对数据进行修改操作时，会等待   而 使用 select for update nowait，数据被锁住时， 对数据进行修改操作时，会报数据库错误   相关资料 http://blog.csdn.net/liqfyiyi/article/details/7948282
oracle commit 时的控制参数 commit_write、commit_logging、commit_wait
一名数据库爱好者的专栏
08-20 3308
os: centos 7.6 db: oracle 19.3 oracle 保证已经 commit 的数据是不会丢失的,最重要的一点是默认的commit动作会触发数据刷盘到 online redo log file,实现持久化. 默认的 commit 语句其实是 commit work write wait immediate. SQL> commit; Commit complete. ...
常用的命令(不断添加中)
oursql的专栏
10-08 749
1、计时：set timing on 2、显示执行计划： set autotrace on 3、显示参数： show parameter;//显示所有参数                 show parameter commit_logging;//显示某个参数  4、修改参数的命令：alter system set commit_logging=batch sc
oracle alter session和alter system的参数详解
gcgl000hugang12345的专栏
06-14 8111
查看系统参数方法： 查看某一个参数值：SHOW PARAMETER db_block_size； 查看多个相关参数值：SHOW PARAMETERS block； 修改系统参数的方法： ALTER SESSION SET parameter_name = value ALTER SYSTEM SET parameter_name = value [DEFERRED
PostgreSQL & Oracle -1 OLTP "update/select based primary key" & insert
postgrechina的博客
10-14 595
基于同一台主机和存储，分别测试PostgreSQL 9.4.1, Oracle 12c 的小事务处理能力。 测试结果仅供参考，有兴趣的同学可以自行测试或者更改测试用例来玩。 (因测试使用工具不一样，工具本身的损耗不一样，结果可能没有可比性。) (即使用同样的工具，驱动的性能可能也不一样，很难做到完全没有偏颇。) (所以，本文目的旨在挑战产品自身的极限或者发现自身的问题和缺陷，而非两种产品的
PostgreSQL VS Oracle OLTP 的测试方法 - 1
weixin_33955681的博客
12-10 118
基于同一台主机和存储，分别测试PostgreSQL 9.4.1, Oracle 12c 的小事务处理能力。 测试结果仅供参考，有兴趣的同学可以自行测试或者更改测试用例来玩。 (因测试使用工具不一样，工具本身的损耗不一样，结果可能没有可比性。) (即使用同样的工具，驱动的性能可能也不一样，很难做到完全没有偏颇。) (所以，本文目的旨在挑战产品自身的极限或者...
PostgreSQL 批量SQL before/after for each row trigger的触发时机、性能差异分析、建议 - 含9.4 , 10版本...
weixin_34162629的博客
10-05 1732
标签 PostgreSQL , trigger , row , statement , before , after , s_lock 背景 数据库触发器的触发时机，性能，高并发批量导入时，触发器的性能如何？ 批量导入时，before, after触发器在for each row模式下，触发机制如何，什么时候开始条到触发器指定的function中进行...
PT环境下postgresql.conf配置参考
steven的博客
11-08 823
# ----------------------------- # PostgreSQL configuration file # ----------------------------- # # This file consists of lines of the form: # # name = value # # (The "=" is optional.) Whitespace may be used. Comments are introduced with # "#" anywhere...
postgresql-9.1.3-1-windows-x64
04-18
PostgreSQL是一种开源关系型数据库管理系统（RDBMS），在IT领域广泛应用，特别是在需要高度可靠性和复杂查询的场景中。此“postgresql-9.1.3-1-windows-x64”压缩包是专为64位Windows系统设计的PostgreSQL 9.1.3版本...
Linux安装postgresql-10.5及搭建从库
joy.chou的博客
04-17 5437
1.下载tar.gz https://www.postgresql.org/ftp/source/ 2.解压到/usr/local # tar -zxvf postgresql-10.5.tar.gz 3.创建用户和组 # groupadd postgres # useradd -g postgres postgres 4.进行编译安装 # cd postgresql-10.5...
MySQL + PostgreSQL批量插入更新insertOrUpdate
2401_83641360的博客
04-19 1744
在这个部分总结了2019年到目前为止Java常见面试问题，取其面试核心编写成这份文档笔记，从中分析面试官的心理，摸清面试官的“套路”，可以说搞定90%以上的Java中高级面试没一点难度。本节总结的内容涵盖了：消息队列、Redis缓存、分库分表、读写分离、设计高并发系统、分布式系统、高可用系统、SpringCloud微服务架构等一系列互联网主流高级技术的知识点。（上述只是一个整体目录大纲，每个点里面都有如下所示的详细内容，从面试问题——分析面试官心理——剖析面试题——完美解答的一个过程）
Linux执行所有install 都报错Errors were encountered while processing: locales E: Sub-process /usr/bin/dpkg
じ☆ve辶寸愘灬
04-28 6366
1、报错信息如下 Errors were encountered while processing: locales E: Sub-process /usr/bin/dpkg returned an error code (1) 2、网上说的用一下命令可以解决，但是我执行到第3步sudo apt-get install -f 这个命令还是会报哪个错 (1)现将info文件夹更名 sudo ...
飞腾X100适配Ubuntu说明
developersupport的博客
10-12 904
主要介绍飞腾X100 GPU软件适配Ubuntu系统的步骤。
MySQL数据库的详细学习步骤
2401_87352036的博客
10-11 1202
MySQL数据库的详细学习步骤可以归纳为以下几个阶段，每个阶段都包含了特定的学习内容和目标。
Rdis的应用，示例，四种模式单机模式、主从模式、哨兵模式、集群模式
最新发布
weixin_66568937的博客
10-16 472
为此， Redis 提供了复制（replication）功能，可以实现当一台数据库中的数据更新后，自动将更新的数据同步到其他数据库上。主从模式在很多系统设计时都会考虑，一个master挂在多个slave节点，当master服务宕机，会选举产生一个新的master节点，从而保证服务的高可用性。从上面很容易就想到一个问题，既然主从复制，意味着master和slave的数据都是一样的，有数据冗余问题。替换原来的故障节点。刚刚提到了，主从模式，当主节点宕机之后，从节点是可以作为主节点顶上来，继续提供服务的。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 278
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
如何使用ssm实现宠物论坛设计网站
寒夜
10-12 970
【代码】ssm宠物论坛设计网站
cp /root/postgresql-10.6/contrib/start-scripts/linux /etc/init.d/postgresql
07-29
"extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值