精华内容
下载资源
问答
  • Oracle数据库中的常用函数

    千次阅读 2017-08-18 18:18:38
    Oracle 数据库中的常用函数分为 字符函数、数值函数、日期函数、...想要全面掌握上面提到的函数,首先应知道Oracle数据库中的数据都有哪些类型,如下所示: 一、字符函数 1,字符串截取  select substr('abcde

    Oracle 数据库中的常用函数分为 字符函数、数值函数、日期函数、转换函数、通用函数、分组函数和聚合函数等类型,熟练掌握这些函数的用法会大大方便我们进行数据处理。下面我对这些函数进行依依介绍,希望能给读者提供帮助。

    想要全面掌握上面提到的函数,首先应知道Oracle数据库中的数据都有哪些类型,如下所示:


    一、字符函数

    1,字符串截取
       select substr('abcdef',1,3) from dual

    2,查找子串位置
       select instr('abcfdgfdhd','fd') from dual

    3,字符串连接
       select 'HELLO'||'hello world' from dual;

    4, 1)去掉字符串中的空格
        select ltrim(' abc') s1,
        rtrim('zhang ') s2,
        trim(' zhang ') s3 from dual

       2)去掉前导和后缀
        select trim(leading 9 from 9998767999) s1,
        trim(trailing 9 from 9998767999) s2,
        trim(9 from 9998767999) s3 from dual;

    5,返回字符串首字母的Ascii值
       select ascii('a') from dual

    6,返回ascii值对应的字母
       select chr(97) from dual

    7,计算字符串长度
       select length('abcdef') from dual

    8,initcap(首字母变大写) ,lower(变小写),upper(变大写)
       select lower('ABC') s1,  
           upper('def') s2,
           initcap('efg') s3
       from dual;

    9,Replace
       select replace('abc','b','xy') from dual;

    10,translate
       select translate('abc','b','xx') from dual; -- x是1位

    11,lpad [左添充] rpad [右填充](用于控制输出格式)
       select lpad('func',15,'=') s1, rpad('func',15,'-') s2 from dual;
       select lpad(dname,14,'=') from dept;

    12, decode[实现if ..then 逻辑]   注:第一个是表达式,最后一个是不满足任何一个条件的值
       select deptno,decode(deptno,10,'1',20,'2',30,'3','其他') from dept;
       例:
       select seed,account_name,decode(seed,111,1000,200,2000,0) from t_userInfo//如果seed为111,则取1000;为200,取2000;其它取0
       select seed,account_name,decode(sign(seed-111),1,'big seed',-1,'little seed','equal seed') from t_userInfo//如果seed>111,则显示大;为200,则显示小;其它则显示相等

    13 case[实现switch ..case 逻辑]
    复制代码 代码如下:

        SELECT CASE X-FIELD
             WHEN X-FIELD < 40 THEN 'X-FIELD 小于 40'
             WHEN X-FIELD < 50 THEN 'X-FIELD 小于 50'
             WHEN X-FIELD < 60 THEN 'X-FIELD 小于 60'
             ELSE 'UNBEKNOWN'
            END
       FROM DUAL  

    二、数值函数

    1,四舍五入函数:round(),默认情况下,round四舍五入取整,可以根据需要自己定义需要保留的小数的位数

    select round(12.1212) from dual;---结果为:12
    select round(12.12234, 2) from dual   --结果为:12.12
    select round(12.6456, 3) from dual   --结果为:12.646

    2. 取整:tranc() ,默认全部去掉小数,也可以自定义保留的位数

    select  trunc(12.2342) from dual;   --结果为:12
    select trunc(12.237,2) from dual;   --结果为:12.23

    3.取余数:mod()

    select mod(10,3) from dual ; --结果为:1

    4,取整函数(ceil 向上取整,floor 向下取整)
       select ceil(66.6) N1,floor(66.6) N2 from dual;

    5, 取幂(power) 和 求平方根(sqrt)
       select power(3,2) N1,sqrt(9) N2 from dual;

    三、日期函数

    1. 日期和字符转换函数用法(to_date,to_char)
             
    select to_char(sysdate,'yyyy-mm-dd hh24:mi:ss') as nowTime from dual;   //日期转化为字符串   
    select to_char(sysdate,'yyyy') as nowYear   from dual;   //获取时间的年   
    select to_char(sysdate,'mm')    as nowMonth from dual;   //获取时间的月   
    select to_char(sysdate,'dd')    as nowDay    from dual;   //获取时间的日   
    select to_char(sysdate,'hh24') as nowHour   from dual;   //获取时间的时   
    select to_char(sysdate,'mi')    as nowMinute from dual;   //获取时间的分   
    select to_char(sysdate,'ss')    as nowSecond from dual;   //获取时间的秒

    select to_date('2004-05-07 13:23:44','yyyy-mm-dd hh24:mi:ss')    from dual//

    2. select to_char( to_date(222,'J'),'Jsp') from dual      

        显示Two Hundred Twenty-Two  

    3.求某天是星期几      
       select to_char(to_date('2002-08-26','yyyy-mm-dd'),'day') from dual;      
       星期一      
       select to_char(to_date('2002-08-26','yyyy-mm-dd'),'day','NLS_DATE_LANGUAGE = American') from dual;      
       monday      
       设置日期语言      
       ALTER SESSION SET NLS_DATE_LANGUAGE='AMERICAN';     

    4. 两个日期间的天数      
        select floor(sysdate - to_date('20020405','yyyymmdd')) from dual;  

    5. 时间为null的用法      
       select id, active_date from table1      
       UNION      
       select 1, TO_DATE(null) from dual;      
       注意要用TO_DATE(null)      

    6.月份差   
       a_date between to_date('20011201','yyyymmdd') and to_date('20011231','yyyymmdd')      
       那么12月31号中午12点之后和12月1号的12点之前是不包含在这个范围之内的。      
       所以,当时间需要精确的时候,觉得to_char还是必要的

    7. 日期格式冲突问题      
        输入的格式要看你安装的ORACLE字符集的类型, 比如: US7ASCII, date格式的类型就是: '01-Jan-01'      
        alter system set NLS_DATE_LANGUAGE = American      
        alter session set NLS_DATE_LANGUAGE = American      
        或者在to_date中写      
        select to_char(to_date('2002-08-26','yyyy-mm-dd'),'day','NLS_DATE_LANGUAGE = American') from dual;      
        注意我这只是举了NLS_DATE_LANGUAGE,当然还有很多,      
        可查看      
        select * from nls_session_parameters      
        select * from V$NLS_PARAMETERS      
    8. 代码如下:

       select count(*)      
       from ( select rownum-1 rnum      
           from all_objects      
           where rownum <= to_date('2002-02-28','yyyy-mm-dd') - to_date('2002-      
           02-01','yyyy-mm-dd')+1      
          )      
       where to_char( to_date('2002-02-01','yyyy-mm-dd')+rnum-1, 'D' )      
            not in ( '1', '7' )     

       查找2002-02-28至2002-02-01间除星期一和七的天数      
       在前后分别调用DBMS_UTILITY.GET_TIME, 让后将结果相减(得到的是1/100秒, 而不是毫秒).      

    9. 查找月份  
    复制代码 代码如下:

        select months_between(to_date('01-31-1999','MM-DD-YYYY'),to_date('12-31-1998','MM-DD-YYYY')) "MONTHS" FROM DUAL;      
        1      
       select months_between(to_date('02-01-1999','MM-DD-YYYY'),to_date('12-31-1998','MM-DD-YYYY')) "MONTHS" FROM DUAL;      
        1.03225806451613

    10. Next_day的用法     复制代码 代码如下:

        Next_day(date, day)      

        Monday-Sunday, for format code DAY      
        Mon-Sun, for format code DY      
        1-7, for format code D    

    11    select to_char(sysdate,'hh:mi:ss') TIME from all_objects      
       注意:第一条记录的TIME 与最后一行是一样的      
       可以建立一个函数来处理这个问题     
    复制代码 代码如下:

       create or replace function sys_date return date is      
       begin      
       return sysdate;      
       end;      

       select to_char(sys_date,'hh:mi:ss') from all_objects;  

    12.获得小时数      
         extract()找出日期或间隔值的字段值
    复制代码 代码如下:

        SELECT EXTRACT(HOUR FROM TIMESTAMP '2001-02-16 2:38:40') from offer      
        SQL> select sysdate ,to_char(sysdate,'hh') from dual;      

        SYSDATE TO_CHAR(SYSDATE,'HH')      
        -------------------- ---------------------      
        2003-10-13 19:35:21 07      

        SQL> select sysdate ,to_char(sysdate,'hh24') from dual;      

        SYSDATE TO_CHAR(SYSDATE,'HH24')      
        -------------------- -----------------------      
        2003-10-13 19:35:21 19     

    13.年月日的处理     
    复制代码 代码如下:
       select older_date, newer_date, years, months,abs(trunc(newer_date- add_months( older_date,years*12+months ))) days
       from ( select      
                trunc(months_between( newer_date, older_date )/12) YEARS,      
                mod(trunc(months_between( newer_date, older_date )),12 ) MONTHS,      
                newer_date,      
                older_date      
            from (select hiredate older_date, add_months(hiredate,rownum)+rownum newer_date from emp)) 


    14.处理月份天数不定的办法      
       select to_char(add_months(last_day(sysdate) +1, -2), 'yyyymmdd'),last_day(sysdate) from dual   
     
    16.找出今年的天数      
       select add_months(trunc(sysdate,'year'), 12) - trunc(sysdate,'year') from dual      
       闰年的处理方法      
       to_char( last_day( to_date('02'    | | :year,'mmyyyy') ), 'dd' )      
       如果是28就不是闰年      
    17.yyyy与rrrr的区别     
    复制代码 代码如下:

       'YYYY99 TO_C      
       ------- ----      
       yyyy 99 0099      
       rrrr 99 1999      
       yyyy 01 0001      
       rrrr 01 2001     

    18.不同时区的处理      
       select to_char( NEW_TIME( sysdate, 'GMT','EST'), 'dd/mm/yyyy hh:mi:ss') ,sysdate      
       from dual;   

    19.5秒钟一个间隔  
    复制代码 代码如下:

       Select TO_DATE(FLOOR(TO_CHAR(sysdate,'SSSSS')/300) * 300,'SSSSS') ,TO_CHAR(sysdate,'SSSSS')      
       from dual      
       2002-11-1 9:55:00 35786      
       SSSSS表示5位秒数     
     

    20.一年的第几天      
       select TO_CHAR(SYSDATE,'DDD'),sysdate from dual

       310 2002-11-6 10:03:51      

    21.计算小时,分,秒,毫秒
    复制代码 代码如下:
        select  Days, A,
             TRUNC(A*24) Hours,      
             TRUNC(A*24*60 - 60*TRUNC(A*24)) Minutes,      
             TRUNC(A*24*60*60 - 60*TRUNC(A*24*60)) Seconds,      
             TRUNC(A*24*60*60*100 - 100*TRUNC(A*24*60*60)) mSeconds      
        from ( select trunc(sysdate) Days, sysdate - trunc(sysdate) A  from dual )
     
    22.next_day函数      返回下个星期的日期,day为1-7或星期日-星期六,1表示星期日
       next_day(sysdate,6)是从当前开始下一个星期五。后面的数字是从星期日开始算起。      
       1 2 3 4 5 6 7      
       日 一 二 三 四 五 六    

       ---------------------------------------------------------------

       select    (sysdate-to_date('2003-12-03 12:55:45','yyyy-mm-dd hh24:mi:ss'))*24*60*60 from ddual
       日期 返回的是天 然后 转换为ss

    23,round[舍入到最接近的日期](day:舍入到最接近的星期日)
       select sysdate S1,
       round(sysdate) S2 ,
       round(sysdate,'year') YEAR,
       round(sysdate,'month') MONTH ,
       round(sysdate,'day') DAY from dual

    24,trunc[截断到最接近的日期,单位为天] ,返回的是日期类型
       select sysdate S1,                     
         trunc(sysdate) S2,                 //返回当前日期,无时分秒
         trunc(sysdate,'year') YEAR,        //返回当前年的1月1日,无时分秒
         trunc(sysdate,'month') MONTH ,     //返回当前月的1日,无时分秒
         trunc(sysdate,'day') DAY           //返回当前星期的星期天,无时分秒
       from dual

    25,返回日期列表中最晚日期
       select greatest('01-1月-04','04-1月-04','10-2月-04') from dual

    26.计算时间差
         注:oracle时间差是以天数为单位,所以换算成年月,日

          select floor(to_number(sysdate-to_date('2007-11-02 15:55:03','yyyy-mm-dd hh24:mi:ss'))/365) as spanYears from dual        //时间差-年
          select ceil(moths_between(sysdate-to_date('2007-11-02 15:55:03','yyyy-mm-dd hh24:mi:ss'))) as spanMonths from dual        //时间差-月
          select floor(to_number(sysdate-to_date('2007-11-02 15:55:03','yyyy-mm-dd hh24:mi:ss'))) as spanDays from dual             //时间差-天
          select floor(to_number(sysdate-to_date('2007-11-02 15:55:03','yyyy-mm-dd hh24:mi:ss'))*24) as spanHours from dual         //时间差-时
          select floor(to_number(sysdate-to_date('2007-11-02 15:55:03','yyyy-mm-dd hh24:mi:ss'))*24*60) as spanMinutes from dual    //时间差-分
          select floor(to_number(sysdate-to_date('2007-11-02 15:55:03','yyyy-mm-dd hh24:mi:ss'))*24*60*60) as spanSeconds from dual //时间差-秒

    27.更新时间
         注:oracle时间加减是以天数为单位,设改变量为n,所以换算成年月,日
         select to_char(sysdate,'yyyy-mm-dd hh24:mi:ss'),to_char(sysdate+n*365,'yyyy-mm-dd hh24:mi:ss') as newTime from dual        //改变时间-年
         select to_char(sysdate,'yyyy-mm-dd hh24:mi:ss'),add_months(sysdate,n) as newTime from dual                                 //改变时间-月
         select to_char(sysdate,'yyyy-mm-dd hh24:mi:ss'),to_char(sysdate+n,'yyyy-mm-dd hh24:mi:ss') as newTime from dual            //改变时间-日
         select to_char(sysdate,'yyyy-mm-dd hh24:mi:ss'),to_char(sysdate+n/24,'yyyy-mm-dd hh24:mi:ss') as newTime from dual         //改变时间-时
         select to_char(sysdate,'yyyy-mm-dd hh24:mi:ss'),to_char(sysdate+n/24/60,'yyyy-mm-dd hh24:mi:ss') as newTime from dual      //改变时间-分
         select to_char(sysdate,'yyyy-mm-dd hh24:mi:ss'),to_char(sysdate+n/24/60/60,'yyyy-mm-dd hh24:mi:ss') as newTime from dual   //改变时间-秒

    28.查找月的第一天,最后一天
         SELECT Trunc(Trunc(SYSDATE, 'MONTH') - 1, 'MONTH') First_Day_Last_Month,
           Trunc(SYSDATE, 'MONTH') - 1 / 86400 Last_Day_Last_Month,
           Trunc(SYSDATE, 'MONTH') First_Day_Cur_Month,
           LAST_DAY(Trunc(SYSDATE, 'MONTH')) + 1 - 1 / 86400 Last_Day_Cur_Month
       FROM dual;

    四、转换函数


    1,to_char()[将日期和数字类型转换成字符类型]
       1) select to_char(sysdate) s1,
            to_char(sysdate,'yyyy-mm-dd') s2,
            to_char(sysdate,'yyyy') s3,
            to_char(sysdate,'yyyy-mm-dd hh12:mi:ss') s4,
            to_char(sysdate, 'hh24:mi:ss') s5,
            to_char(sysdate,'DAY') s6
        from dual;
       2) select sal,to_char(sal,'$99999') n1,to_char(sal,'$99,999') n2 from emp

    2, to_date()[将字符类型转换为日期类型]
        insert into emp(empno,hiredate) values(8000,to_date('2004-10-10','yyyy-mm-dd'));

    3, to_number() 转换为数字类型
        select to_number(to_char(sysdate,'hh12')) from dual; //以数字显示的小时数

    五、通用函数

    1.空值处理nvl

    范例:查询所有的雇员的年薪


    我们发现很多员工的年薪是空的,原因是很多员工的奖金是null,null和任何数值计算都是null,这时我们可以使用nvl来处理。



    2.Decode函数

    该函数类似if....else if...esle

    语法:DECODE( col/expression ,[search1,result1],[search2, result2]....[default]),例子如下:


    select enamel,decode(job, 'salesman','销售员',‘president’,'总裁',‘manager’,'经理',‘无业游民’) from emp;

    3.case when

    CASE expr

              WHEN comparison_expr1 THEN return_expr1

             WHENcomparison_expr2 THEN return_expr2

              WHENcomparison_exprn THEN return_exprn

              ELSE   else_expr

    END

    使用案例如下:

    selectt.empno, t.ename,

    case

    when t.job = 'CLERK' then  '业务员'

    whent.job = 'MANAGER' then  '经理'

    whent.job = 'ANALYST' then  '分析员'

    whent.job = 'PRESIDENT' then  '总裁'

    whent.job = 'SALESMAN' then  '销售'

    else  '无业'

    end

    from emp t


    6.聚合函数

    常用的聚合函数只有这几种:avg(),min(),max(),sum(),count() ,这个相对来说比较简单常用,不做依依讲解

    需要注意的事项为:当查询的 字段 与 聚合函数组合使用时(既有常用字段,又有聚合函数包含的字段),这时常规字段需要使用 group by 进行分组,

    简单案例如下:

    如果查询的字段不在 group by  后边 ,会出现下边的问题:













    展开全文
  • sql server中查询数据库中有哪些

    千次阅读 2013-07-18 15:44:34
    系统表sysobjects保存的都是数据库对象,其中type表示各种对象的类型,具体包括: U = 用户表 S = 系统表 C = CHECK 约束 D = 默认值或 DEFAULT 约束 F = FOREIGN KEY 约束 L = 日志 FN = 标量函数 IF = 内嵌表函数 P ...
    系统表sysobjects保存的都是数据库对象,其中type表示各种对象的类型,具体包括:
    U = 用户表
    S = 系统表
    C = CHECK 约束
    D = 默认值或 DEFAULT 约束
    F = FOREIGN KEY 约束
    L = 日志
    FN = 标量函数
    IF = 内嵌表函数
    P = 存储过程
    PK = PRIMARY KEY 约束(类型是 K)
    RF = 复制筛选存储过程
    TF = 表函数
    TR = 触发器
    UQ = UNIQUE 约束(类型是 K)
    V = 视图
    X = 扩展存储过程及相关的对象信息。

    PS:打开数据库

    use SALES
    go


    故:select name from sysobjects where type = 'U';可以查询用户表有哪些
    展开全文
  • 以下只是我针对数据库查询慢这个问题想到的可能的原因和一些解决办法的简单罗列,每一个问题和解决办法都可以详细描述很多,后面的再针对每一个点进行谈论 ... 数据库中的单表的数据量达到了多少?1000万?500.

    以下只是我针对数据库查询慢这个问题想到的可能的原因和一些解决办法的简单罗列,每一个问题和解决办法都可以详细描述很多,后面的再针对每一个点进行谈论

     

    一、应用的问题

    1. 数据库表设计不合理,应该加索引的字段没有加索引
    2. 查询sql语句是不是编写不合理,查询的时候没有加索引
    3. 查询sql语句的条件加了索引,但是查询的时候没有命中索引,比如:前缀匹配失效、条件字段做了类型转换或者使用了函数、使用了范围查询等;使用 explain 查看索引命中情况 ;参考
    4. join的表太多了???
    5. 数据库中的单表的数据量达到了多少?1000万?5000万?是不是考虑分库分表;参考
      1. 分库分表怎么选取分片键?
      2. 分库分表后怎么查询?
      3. 分库分表的算法?一致性hash环?
      4. 分库分表的节点个数怎么考虑
    6. 程序异常导致大量数据库连接不能释放,一直被占用?

    二、数据库的问题

    1. 参数优化,连接池资源不够用了
    2. 数据库所在的硬件资源情况:当查询慢的时候,内存占了多少?mysql磁盘IO是不是被其它应用共享且占用高?cpu是不是有负载?
      1. 硬件资源本身不够>加资源
      2. 硬件资源因为和其它进程共享,导致资源不够,可以考虑做资源隔离
      3. 硬件资源性能不足,比如磁盘可以考虑换成SSD
    3. 网络资源
      1. 应用连接数据库的网络是不是抖动,延时较高

    三、请求量太大

    1. 如果数据量真的炒鸡大,分库分表已经不能满足查询了,考虑将热点数据在redis做缓存
      1. 应用架构调整,把缓存模块加进去
      2. 如果已经加了缓存还是慢,会不会是缓存雪崩了?击穿了?缓存命中率低?
    2. 缓存任然不能满足查询要求,比如很多字段的查询,可以将查询字段放到ES等大数据组件中,先查ES,ES拿到数据主键id再到MySQL中查询
    3. 用户请求突然增加,导致查询变慢
      1. 上有系统出现bug,导致循环调用接口做查询,这个时候是不是考虑异常情况限流
      2. 用户请求真的是大量增加了,公司发展迅猛

     

     

     

     

     

    展开全文
  • 可以查询数据库中有哪些表,表有哪些字段,字段的属性等等。MetaData中通过一系列getXXX函数,将这些信息存放到ResultSet里面,然后返回给用户。关于MetaData的说明网上也有不少,这里我只是从我自身学习的角度来...

      1、JDBC中通过MetaData来获取具体的表的相关信息。可以查询数据库中的有哪些表,表有哪些字段,字段的属性等等。MetaData中通过一系列getXXX函数,将这些信息存放到ResultSet里面,然后返回给用户。关于MetaData的说明网上也有不少,这里我只是从我自身学习的角度来记录一下简单使用JDBC以及获取数据表相关信息的方法。 

    DatabaseMetaData dbmd = con.getMetaData(); 
    rs = dbmd.getColumns(con.getCatalog(), schema, tableName, null); 
    rs.getString(DATA_TYPE) // java.sql.Types 的 SQL 类型 
    rs.getString(COLUMN_SIZE) //列的大小。对于 char 或 date 类型,列的大小是最大字符数,对于 numeric 和 decimal 类型,列的大小就是精度。 
    rs.getString(DECIMAL_DIGITS) //小数部分的位数

      2、下面就是我的JDBC下的获取表信息的代码了。我是以MySQL 5.0作为测试平台的。可以通过下面四个步骤来实现:

    //1. JDBC连接MYSQL的代码很标准。 
    class.forName("com.mysql.jdbc.Driver").newInstance(); 
    Connection conn = DriverManager.getConnection("jdbc:mysql://localhost/test?user=root&password=123456");
    
    //2. 下面就是获取表的信息。 
    m_DBMetaData = m_Connection.getMetaData(); 
    ResultSet tableRet = m_DBMetaData.getTables(null, "%",m_TableName,new String[]{"TABLE"}); 
    /*其中"%"就是表示*的意思,也就是任意所有的意思。其中m_TableName就是要获取的数据表的名字,如果想获取所有的表的名字,就可以使用"%"来作为参数了。*/
    
    //3. 提取表的名字。 
    while(tableRet.next) System.out.println(tableRet.getString("TABLE_NAME"));
    
    /*通过getString("TABLE_NAME"),就可以获取表的名字了。 
    从这里可以看出,前面通过getTables的接口的返回,JDBC是将其所有的结果,保存在一个类似table的内存结构中,而其中TABLE_NAME这个名字的字段就是每个表的名字。*/
    
    //4. 提取表内的字段的名字和类型 
    String columnName; 
    String columnType; 
    ResultSet colRet = m_DBMetaData.getColumns(null,"%", m_TableName,"%"); 
    while(colRet.next()) { 
      columnName = colRet.getString("COLUMN_NAME"); 
      columnType = colRet.getString("TYPE_NAME"); 
      int datasize = colRet.getInt("COLUMN_SIZE"); 
      int digits = colRet.getInt("DECIMAL_DIGITS"); 
      int nullable = colRet.getInt("NULLABLE"); 
      System.out.println(columnName+" "+columnType+" "+datasize+" "+digits+" "+ nullable); 
    }
    
    /*JDBC里面通过getColumns的接口,实现对字段的查询。跟getTables一样,"%"表示所有任意的(字段),而m_TableName就是数据表的名字。
    
    getColumns的返回也是将所有的字段放到一个类似的内存中的表,而COLUMN_NAME就是字段的名字,TYPE_NAME就是数据类型,比如"int","int unsigned"等等,COLUMN_SIZE返回整数,就是字段的长度,比如定义的int(8)的字段,返回就是8,最后NULLABLE,返回1就表示可以是Null,而0就表示Not Null。*/
    每个列描述都有以下列: 
    
    TABLE_CAT String => 表类别(可为 null) 
    TABLE_SCHEM String => 表模式(可为 null) 
    TABLE_NAME String => 表名称 
    COLUMN_NAME String => 列名称 
    DATA_TYPE int => 来自 java.sql.Types 的 SQL 类型 
    TYPE_NAME String => 数据源依赖的类型名称,对于 UDT,该类型名称是完全限定的 
    COLUMN_SIZE int => 列的大小。 
    BUFFER_LENGTH 未被使用。 
    DECIMAL_DIGITS int => 小数部分的位数。对于 DECIMAL_DIGITS 不适用的数据类型,则返回 Null。 
    NUM_PREC_RADIX int => 基数(通常为 102) 
    NULLABLE int => 是否允许使用 NULL。 
    columnNoNulls - 可能不允许使用 NULL 值 
    columnNullable - 明确允许使用 NULL 值 
    columnNullableUnknown - 不知道是否可使用 null 
    REMARKS String => 描述列的注释(可为 null) 
    COLUMN_DEF String => 该列的默认值,当值在单引号内时应被解释为一个字符串(可为 null) 
    SQL_DATA_TYPE int => 未使用 
    SQL_DATETIME_SUB int => 未使用 
    CHAR_OCTET_LENGTH int => 对于 char 类型,该长度是列中的最大字节数 
    ORDINAL_POSITION int => 表中的列的索引(从 1 开始) 
    IS_NULLABLE String => ISO 规则用于确定列是否包括 null。 
    YES --- 如果参数可以包括 NULL 
    NO --- 如果参数不可以包括 NULL 
    空字符串 --- 如果不知道参数是否可以包括 null 
    SCOPE_CATLOG String => 表的类别,它是引用属性的作用域(如果 DATA_TYPE 不是 REF,则为 null) 
    SCOPE_SCHEMA String => 表的模式,它是引用属性的作用域(如果 DATA_TYPE 不是 REF,则为 null) 
    SCOPE_TABLE String => 表名称,它是引用属性的作用域(如果 DATA_TYPE 不是 REF,则为 null) 
    SOURCE_DATA_TYPE short => 不同类型或用户生成 Ref 类型、来自 java.sql.Types 的 SQL 类型的源类型(如果 DATA_TYPE 不是 DISTINCT 或用户生成的 REF,则为 null) 
    IS_AUTOINCREMENT String => 指示此列是否自动增加 
    YES --- 如果该列自动增加 
    NO --- 如果该列不自动增加 
    空字符串 --- 如果不能确定该列是否是自动增加参数 
    COLUMN_SIZE 列表示给定列的指定列大小。对于数值数据,这是最大精度。对于字符数据,这是字符长度。对于日期时间数据类型,这是 String 表示形式的字符长度(假定允许的最大小数秒组件的精度)。对于二进制数据,这是字节长度。对于 ROWID 数据类型,这是字节长度。对于列大小不适用的数据类型,则返回 Null。 
    
    
    参数:
    catalog - 类别名称;它必须与存储在数据库中的类别名称匹配;该参数为 "" 表示获取没有类别的那些描述;为 null 则表示该类别名称不应该用于缩小搜索范围
    schemaPattern - 模式名称的模式;它必须与存储在数据库中的模式名称匹配;该参数为 "" 表示获取没有模式的那些描述;为 null 则表示该模式名称不应该用于缩小搜索范围
    tableNamePattern - 表名称模式;它必须与存储在数据库中的表名称匹配
    columnNamePattern - 列名称模式;它必须与存储在数据库中的列名称匹配 

      3、获取所有表 

    String catalog = conn.getCatalog(); //catalog 其实也就是数据库名  
    ResultSet tablesResultSet = dbMetaData.getTables(catalog,null,null,new String[]{"TABLE"});  
    while(tablesResultSet.next()){  
        String tableName = tablesResultSet.getString("TABLE_NAME");  
    }  

    tablesResultSet 中有以下列: 

    TABLE_CAT String => 表类别(可为 null)
    TABLE_SCHEM String => 表模式(可为 null)
    TABLE_NAME String => 表名称
    TABLE_TYPE String => 表类型。典型的类型是 "TABLE"、"VIEW"、"SYSTEM TABLE"、"GLOBAL TEMPORARY"、"LOCAL TEMPORARY"、"ALIAS" 和 "SYNONYM"。
    REMARKS String => 表的解释性注释
    TYPE_CAT String => 类型的类别(可为 null)
    TYPE_SCHEM String => 类型模式(可为 null)
    TYPE_NAME String => 类型名称(可为 null)
    SELF_REFERENCING_COL_NAME String => 有类型表的指定 "identifier" 列的名称(可为 null)
    REF_GENERATION String => 指定在 SELF_REFERENCING_COL_NAME 中创建值的方式。这些值为 "SYSTEM"、"USER" 和 "DERIVED"。(可能为 null

      4、某个表的主键 

    String tableName = ...;  
    ResultSet primaryKeyResultSet = dbMetaData.getPrimaryKeys(catalog,null,tableName);  
    while(primaryKeyResultSet.next()){  
        String primaryKeyColumnName = primaryKeyResultSet.getString("COLUMN_NAME");  
    }  
    primayKeyResultSet 有以下几列: 
    
    TABLE_CAT String => 表类别(可为 null)
    TABLE_SCHEM String => 表模式(可为 null)
    TABLE_NAME String => 表名称
    COLUMN_NAME String => 列名称
    KEY_SEQ short => 主键中的序列号(值 1 表示主键中的第一列,值 2 表示主键中的第二列)。
    PK_NAME String => 主键的名称(可为 null

      5、某个表的外键 

     
    ResultSet foreignKeyResultSet = dbMetaData.getImportedKeys(catalog,null,tableName);  
    while(foreignKeyResultSet.next()){  
        String fkColumnName = foreignKeyResultSet.getString("FKCOLUMN_NAM");  
        String pkTablenName = foreignKeyResultSet.getString("PKTABLE_NAME");  
        String pkColumnName = foreignKeyResultSet.getString("PKCOLUMN_NAME");  
    }  
    foreignKeyResultSet 有以下几列: 
    
    PKTABLE_CAT String => 被导入的主键表类别(可为 null)
    PKTABLE_SCHEM String => 被导入的主键表模式(可为 null)
    PKTABLE_NAME String => 被导入的主键表名称
    PKCOLUMN_NAME String => 被导入的主键列名称
    FKTABLE_CAT String => 外键表类别(可为 null)
    FKTABLE_SCHEM String => 外键表模式(可为 null)
    FKTABLE_NAME String => 外键表名称
    FKCOLUMN_NAME String => 外键列名称
    KEY_SEQ short => 外键中的序列号(值 1 表示外键中的第一列,值 2 表示外键中的第二列)
    UPDATE_RULE short => 更新主键时外键发生的变化
    DELETE_RULE short => 删除主键时外键发生的变化
    PK_NAME String => 主键的名称(可为 null)
    FK_NAME String => 外键的名称(可为 null)
    DEFERRABILITY short => 是否可以将对外键约束的评估延迟到提交时间

      6、应用:

      大多数数据库有许多主键,但是在一个表中不允许两条记录的同一个主键具有相同的值。可以使用Java Database Connectivity(JDBC)来判断一个数据表的主键。 JDBC具有强大的元数据处理能力。java.sql.Connection类和java.sql.ResultSet类可以通过调用其getMetaData方法进行反射。可以通过下面两个方法:

    //这两个方法都可以获取主外键信息,只是参照物不同
    metaData.getExportedKeys("数据库名称", "schema", "表名");
    metaData.getImportedKeys(catalog, null, tablename);
    //Sql Server
     private static String url = "jdbc:sqlserver://192.168.1.220:1433;User=admin;Password=123456;DatabaseName=Person";
    package cn.test;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.sql.Connection;
    import java.sql.DatabaseMetaData;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;
    
    public class TestAll {
        private static String path = "D:\\tool\\project\\DynamicTable\\src\\cn\\test\\entity";
        private static String pkname = "com.mysql.jdbc.Driver";
        private static String url = "jdbc:mysql://192.168.1.220:3306/Person";
        private static String[] classNames = new String[] { "ShipStopping",
                "ArriveShip", "TBLUserType" };
        private static Map<String, String> fkTableNamesAndPk = new HashMap<String, String>();
    
        public static void main(String[] args) {
            test();
        }
    
        public static void test() {
            Connection conn = null;
            DatabaseMetaData metaData = null;
            ResultSet rs = null;
            ResultSet crs = null;
            try {
                Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
                conn = DriverManager.getConnection(url, "admin", "123");
                String catalog = conn.getCatalog(); // catalog 其实也就是数据库名
                metaData = conn.getMetaData();
                File dirFile = new File(path);
                if (!dirFile.exists()) {
                    dirFile.mkdirs();
                }
                // 获取表
                rs = metaData.getTables(null, "%", "%", new String[] { "TABLE" });
                while (rs.next()) {
                    String tablename = rs.getString("TABLE_NAME");
                    String classname = getClassNameByTableName(tablename);
                    StringBuffer sb = new StringBuffer();
                    StringBuffer sbpackage = new StringBuffer();
                    sbpackage.append("package cn.test.entity;\r\n\r\n");
                    sbpackage.append("import javax.persistence.Column;\r\n");
                    sbpackage.append("import javax.persistence.Entity;\r\n");
                    sbpackage.append("import javax.persistence.GeneratedValue;\r\n");
                    sbpackage.append("import javax.persistence.Id;\r\n");
                    sbpackage.append("import javax.persistence.Table;\r\n\r\n");
                    sb.append("\r\n@Entity\r\n");
                    sb.append("@Table(name = \"" + tablename + "\")\r\n");
                    sb.append("public class " + classname
                            + " implements java.io.Serializable {\r\n");
                    // 获取当前表的列
                    crs = metaData.getColumns(null, "%", tablename, "%");
                    // 获取被引用的表,它的主键就是当前表的外键 
                    fkTableNamesAndPk.clear();
                    ResultSet foreignKeyResultSet = metaData.getImportedKeys(catalog, null, tablename);
                    while (foreignKeyResultSet.next()) {
                        String pkTablenName = foreignKeyResultSet.getString("PKTABLE_NAME"); // 外键表
                        String fkColumnName = foreignKeyResultSet.getString("FKCOLUMN_NAME"); // 外键
                        if (!fkTableNamesAndPk.containsKey(fkColumnName))
                            fkTableNamesAndPk.put(fkColumnName, pkTablenName);
                    }
                    // foreignKeyResultSet.close();
                    while (crs.next()) {
                        String columnname = crs.getString("COLUMN_NAME");
                        String columntype = crs.getString("TYPE_NAME");
                        System.out.println("--------------------------"+ columntype);
                        if (existFKColumn(columnname)) {
                            String fkclassname = getClassNameByTableName(fkTableNamesAndPk.get(columnname));
                            sbpackage.append("import " + pkname + "." + fkclassname+ ";\r\n");
                            sb.append("\t/**    */\r\n");
                            sb.append("\tprivate " + fkclassname + " " + columnname+ ";\r\n");
                        } else {
                            sb.append("\t/**    */\r\n");
                            sb.append("\tprivate "+ getFieldType(columntype, sbpackage) + " "+ columnname + ";\r\n");
                        }
                    }
                    sb.append("}");
                    File file = new File(dirFile, classname + ".java");
                    if (file.exists()) {
                        file.delete();
                    }
                    getTitle(sbpackage, classname);
                    FileOutputStream outputStream = new FileOutputStream(file);
                    outputStream.write(sbpackage.toString().getBytes());
                    outputStream.write(sb.toString().getBytes());
                    outputStream.close();
                    System.out.println(classname + " create success ... ");
                }
            } catch (Exception e) {
                e.printStackTrace(System.out);
            } finally {
                try {
                    if (null != rs) {
                        rs.close();
                    }
                    if (null != conn) {
                        conn.close();
                    }
                } catch (Exception e2) {
                }
            }
        }
    
        /**
         * 根据表名获取类名称
         * 
         * @param tablename
         * @return
         */
        private static String getClassNameByTableName(String tablename) {
            String classname = getClassName(tablename);
            for (String name : classNames) {
                if (name.toLowerCase().equals(tablename.toLowerCase())) {
                    classname = name;
                }
            }
            return classname;
        }
    
        private static boolean existFKColumn(String columnname) {
            if (fkTableNamesAndPk != null) {
                if (fkTableNamesAndPk.containsKey(columnname))
                    return true;
            }
            return false;
        }
    
        /**
         * 适合表名为单个单词, 例如:表名是TBLUSER 类名是TBLUser;当表名是USER 类名是User;当表面是USERTYPE(两个单词)
         * 时,类名是Usertype,如果要 UserType,将期望的类名添加到classNames字段中(与数据库表名一致 不区分大小写)。
         * 
         * @param tablename
         * @return
         */
        public static String getClassName(String tablename) {
            String res = tablename.toLowerCase();
            if (tablename.startsWith("TBL")) {
                return tablename.substring(0, 4) + res.substring(4);
            }
            return tablename.substring(0, 1).toUpperCase() + res.substring(1);
        }
    
        /**
         * 设置字段类型 MySql数据类型
         * 
         * @param columnType
         *            列类型字符串
         * @param sbpackage
         *            封装包信息
         * @return
         */
        public static String getFieldType(String columnType, StringBuffer sbpackage) {
            /*
             * tinyblob tinyblob byte[] 
                tinytext varchar java.lang.string 
                blob blob byte[] 
                text varchar java.lang.string 
                mediumblob mediumblob byte[] 
                mediumtext varchar java.lang.string 
                longblob longblob byte[] 
                longtext varchar java.lang.string 
                enum('value1','value2',...) char java.lang.string 
                set('value1','value2',...) char java.lang.string 
             */
            columnType = columnType.toLowerCase();
            if (columnType.equals("varchar") || columnType.equals("nvarchar")
                    || columnType.equals("char") 
    //                || columnType.equals("tinytext")
    //                || columnType.equals("text") 
    //                || columnType.equals("mediumtext")
    //                || columnType.equals("longtext")
                    ) {
                return "String";
            } else if (columnType.equals("tinyblob")
                    ||columnType.equals("blob")
                    ||columnType.equals("mediumblob")
                    ||columnType.equals("longblob")) {
                return "byte[]1111";
            } else if (columnType.equals("datetime")
                    ||columnType.equals("date")
                    ||columnType.equals("timestamp")
                    ||columnType.equals("time")
                    ||columnType.equals("year")) {
                sbpackage.append("import java.util.Date;\r\n");
                return "Date";
            } else if (columnType.equals("bit")
                    ||columnType.equals("int")        
                    ||columnType.equals("tinyint")        
                    ||columnType.equals("smallint")        
    //                ||columnType.equals("bool")        
    //                ||columnType.equals("mediumint")        
    //                ||columnType.equals("bigint")
                    ) {
                return "int";
            } else if (columnType.equals("float")) {
                return "Float";
            } else if (columnType.equals("double")) {
                return "Double";
            } else if (columnType.equals("decimal")) {
    //            sbpackage.append("import java.math.BigDecimal;\r\n");
    //            return "BigDecimal";
            }
            return "ErrorType";
        }
    
        /**
         * 设置类标题注释
         * 
         * @param sbpackage
         * @param className
         */
        public static void getTitle(StringBuffer sbpackage, String className) {
            SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日");
            sbpackage.append("\r\n/**\r\n");
            sbpackage.append("*\r\n");
            sbpackage.append("* 标题: " + className + "<br/>\r\n");
            sbpackage.append("* 说明: <br/>\r\n");
            sbpackage.append("*\r\n");
            sbpackage.append("* 作成信息: DATE: " + format.format(new Date())
                    + " NAME: author\r\n");
            sbpackage.append("*\r\n");
            sbpackage.append("* 修改信息<br/>\r\n");
            sbpackage.append("* 修改日期 修改者 修改ID 修改内容<br/>\r\n");
            sbpackage.append("*\r\n");
            sbpackage.append("*/\r\n");
        }
    
    }

     

     单表实现:

      根据查询语句,获取表结构信息。

    package cn.test;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    
    public class Test {
        private static String path="D:\\tool\\project\\DynamicTable\\src\\cn\\test\\entity";
        private static String url = "jdbc:sqlserver://192.168.1.220:1433;User=cjtc;Password=cjtc;DatabaseName=Person";
        public static void main(String[] args) {
            test();
        }
        public static void test() {
            Connection conn = null;
            PreparedStatement ps = null;
            ResultSet rs = null;
            StringBuffer sb=new StringBuffer();
            try {
                Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
                conn = DriverManager.getConnection(url);
                String sql = "select * from TBLACCOUNT";
                ps = conn.prepareStatement(sql);
                rs = ps.executeQuery();
                sb.append("package cn.test.entity;\r\n");
                sb.append("public class TBLACCOUNT {\r\n");
                File dirFile = new File(path);
                if (!dirFile.exists()) {
                    dirFile.mkdirs();
                }
                // 获取列名及类型
                int colunmCount = rs.getMetaData().getColumnCount();
                String[] colNameArr = new String[colunmCount];
                String[] colTypeArr = new String[colunmCount];
                for (int i = 0; i < colunmCount; i++) {
                    colNameArr[i] = rs.getMetaData().getColumnName(i + 1);
                    colTypeArr[i] = rs.getMetaData().getColumnTypeName(i + 1);
                    System.out.println(colNameArr[i] + "(" + colTypeArr[i] + ")"+ " | ");
                    if (colTypeArr[i].equals("varchar")||colTypeArr[i].equals("nvarchar")) {
                        sb.append("\tprivate String "+colNameArr[i]+";\r\n");
                        
                    }else if (colTypeArr[i].equals("datetime")) {
    
                    } else if (colTypeArr[i].equals("int")) {
    
                    }
                }
                sb.append("}");
                File file = new File(dirFile,"TBLACCOUNT.java");
                if(file.exists()){
                    file.delete();
                }
                FileOutputStream outputStream = new FileOutputStream(file);
                outputStream.write(sb.toString().getBytes());
                outputStream.close();
                System.out.println(" success ... ");
            } catch (Exception e) {
                e.printStackTrace(System.out);
            } finally {
                try {
                    if (null != rs) {
                        rs.close();
                    }
                    if (null != ps) {
                        ps.close();
                    }
                    if (null != conn) {
                        conn.close();
                    }
                } catch (Exception e2) {
                }
            }
        }
    }

     

    转载于:https://www.cnblogs.com/lbangel/p/3487796.html

    展开全文
  • 可以查询数据库中有哪些表,表有哪些字段,字段的属性等等。MetaData中通过一系列getXXX函数,将这些信息存放到ResultSet里面,然后返回给用户。关于MetaData的说明网上也有不少,这里我只是从我自身学习的角度来...
  • 7、索引类型有哪些? 8、什么是事务?什么是锁? 9、什么叫视图?游标是什么? 10、视图的优缺点 11、列举几种表连接方式,有什么区别? 12、主键和外键的区别? 13、在数据库中查询语句速度很慢,如...
  • 对于初学者,在处理数据库中的Null资料型态是一点麻烦的事,在这篇文章文章中我们将谈谈Null,你将会了解到如何知道一个值是Null,哪些函数可以或不可以处理Null首先,我们必须知道在VBScript中,Variant是唯一的一种...
  • 数据库笔试题

    2017-10-19 18:17:53
    【选择题】1、下列哪个ORACLE函数可以取得数据库系统时间:()...2、下面选项哪些属于ORACLE定义的数据类型:()A、NUMBER B、STRING C、INT D、VARCHAR2 3、EMP表的EMP_NAME字段如下4条记录,执行如下SQL语句:
  • 函数知识点

    2020-05-22 17:19:18
    SQL sever数据库中常用的聚合函数有哪些? 最大值 Max(), 平均值Avg(), 数据条数Count(),最小值Min(), 总和 Sum() 函数的作用 数据库中函数封装了一些通用的功能,例如日期类型和字符串类型之间的转换,每个...
  • Memcache与Redis的区别都有哪些? ● 存储方式不同,Memcache是把数据全部存在内存,数据不能超过内存的大小,断电后数据库会挂掉。Redis有部分存在硬盘上,这样能保证数据的持久性。 ● 数据支持的类型不同...
  • 目录(?...可以查询数据库中有哪些表,表有哪些字段,字段的属性等等。MetaData中通过一系列getXXX函数,将这些信息存放到ResultSet里面,然后返回给用户。关于MetaData的说明网上也有不少,这里我
  • oracle数据库经典题目

    2011-02-17 15:05:20
    18. 表空间是Oracle数据库中数据的逻辑组织,每个数据库至少一个SYSTEM系统表空间。 19.视图是一个表示表的数据的数据库对象,它允许用户从一个表或一组表中通过一定的查询语句建立一个“虚表”。 20.序列是一种...
  • 2018/11/7数据库测试

    2018-12-10 11:30:06
    2.常见的数据库产品有哪些?3.写出MySQL常用命令:进入某个库,查询某个库的所有表,创建数据库。4.请写出MySQL常见的数据类型。5.写出MySQL创建表的语法6. MySQL完整性约束有什么作用?7.MySQLLIMIT关键字是...
  • 那Oracle数据库中有哪几个常用对象呢?表、视图、序列、索引、同义词、存储过程、存储函数、触发器、包、包体。 1.1 表空间 在创建表时字段可以指定哪些数据类型?如下 这里说一下ROWID,它是一个伪列 ...
  • 再简单点,这台MySQL服务器上,到底有哪些数据库、各个数据库有哪些表, 每张表的字段类型是什么,各个数据库要什么权限才能访问,等等信息都保存在information_schema里面。 information_schema的表schemata的列...
  •  第3章 米之炊——数据库的创建与删除  3.1 创建数据库  3.1.1 数据库创建概述  3.1.2 solaris下用dbca创建数据库  3.1.3 diy——solaris下手工创建数据库  3.1.4 数据库创建疑难解析  3.2 删除...
  •  第3章 米之炊——数据库的创建与删除  3.1 创建数据库  3.1.1 数据库创建概述  3.1.2 solaris下用dbca创建数据库  3.1.3 diy——solaris下手工创建数据库  3.1.4 数据库创建疑难解析  3.2 删除...
  • 1. MySQL 索引使用有哪些注意事项呢? 可以从三个维度回答这个问题:索引哪些情况会失效,索引不适合哪些场景,索引规则 索引哪些情况会失效 查询条件包含or,可能导致索引失效 如何字段类型是字符串,where时...
  • 100道MySQL数据库面试题解析

    千次阅读 2020-08-17 10:22:05
    1. MySQL索引使用有哪些注意事项呢? 可以从三个维度回答这个问题:索引哪些情况会失效,索引不适合哪些场景,索引规则 索引哪些情况会失效 查询条件包含or,可能导致索引失效 如何字段类型是字符串,where时一定用...
  • 1.3 数据库类型 6 1.3.1 联机事务处理和决策支持系统数据库 6 1.3.2 开发、测试和产品数据库 7 1.4 培训和认证 7 1.4.1 培训 7 1.4.2 认证 8 1.4.3 Oracle DBA的资源和组织 10 1.4.4 Oracle示例 ...
  •  第3章 米之炊——数据库的创建与删除  3.1 创建数据库  3.1.1 数据库创建概述  3.1.2 solaris下用dbca创建数据库  3.1.3 diy——solaris下手工创建数据库  3.1.4 数据库创建疑难解析  3.2 删除...
  •  第3章 米之炊——数据库的创建与删除  3.1 创建数据库  3.1.1 数据库创建概述  3.1.2 Solaris下用DBCA创建数据库  3.1.3 DIY——Solaris下手工创建数据库  3.1.4 数据库创建疑难解析  3.2 删除...
  •  第3章 米之炊——数据库的创建与删除  3.1 创建数据库  3.1.1 数据库创建概述  3.1.2 solaris下用dbca创建数据库  3.1.3 diy——solaris下手工创建数据库  3.1.4 数据库创建疑难解析  3.2 删除...
  •  第3章 米之炊——数据库的创建与删除  3.1 创建数据库  3.1.1 数据库创建概述  3.1.2 solaris下用dbca创建数据库  3.1.3 diy——solaris下手工创建数据库  3.1.4 数据库创建疑难解析  3.2 删除...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 332
精华内容 132
关键字:

数据库中函数类型有哪些