起名javascript运动系列第一首——匀速运动

眼前的口舌

  除了拖拽外边,运动也是javascript动画的一个基本操作。通过CSS属性transition和animation得实现活动。但是,要拓展双重细地操作,javascript运动是必要的。本文将详细介绍javascript运动

 

一、创建表

粗略运动

  让一个素以页面中移动兴起非常简短,设置定时器,改变定位元素的left或top值即可

<button id="btn">开始运动</button>
<button id="reset">还原</button>
<div id="test" style="height: 100px;width: 100px;background-color: pink;position:absolute;left:0;"></div>
<script>
var timer;
reset.onclick = function(){history.go();}
btn.onclick = function(){
    timer = setInterval(function(){
        if(test.offsetLeft < 500){
            test.style.left = test.offsetLeft + 10 + 'px';
        }else{
            test.style.left = '500px';
            clearInterval(timer);
        }    
    },30);
}
</script>

CREATE TABLE  <表名>

定时器管理

  上面的代码中并未进行定时器管理。当元素以动的经过中,多次比照下按钮,会开启多个定时器,从而使元素运动速度加快

  有零星种定时器管理办法

【1】开启新定时器前,消除旧定时器

  [注意]虽没定时器的状况下,消除定时器也非会见报错,只是静默失败

<button id="btn">开始运动</button>
<button id="reset">还原</button>
<div id="test" style="height: 100px;width: 100px;background-color: pink;position:absolute;left:0;"></div>
<script>
var timer;
reset.onclick = function(){history.go();}
btn.onclick = function(){
    clearInterval(timer);
    timer = setInterval(function(){
        if(test.offsetLeft < 500){
            test.style.left = test.offsetLeft + 10 + 'px';
        }else{
            test.style.left = '500px';
            clearInterval(timer);
        }    
    },30);
}
</script>

【2】当定时器未终止时,不允被新定时器

  [注意]是因为定时器开启时,其回来回值是一个无为0的平头,所以可以经过判断该回到值,来规定是不是采取return语句

<button id="btn">开始运动</button>
<button id="reset">还原</button>
<div id="test" style="height: 100px;width: 100px;background-color: pink;position:absolute;left:0;"></div>
<script>
var timer;
reset.onclick = function(){history.go();}
btn.onclick = function(){
    if(timer) return;
    timer = setInterval(function(){
        if(test.offsetLeft < 500){
            test.style.left = test.offsetLeft + 10 + 'px';
        }else{
            test.style.left = '500px';
            clearInterval(timer);
        }    
    },30);
}
</script>

(<列名><数据类型>[列级完整性约束规范]

享受功能

  现在如举行一个近似于“分享至”侧边栏的职能

<style>
#test{
    width: 100px;
    height: 100px;
    background-color: lightblue;
    text-align:center;
    position:absolute;
    top: 0;
    left: -100px;
}    
#test-in{
    width: 30px;
    height: 60px;
    background-color: orange;
    margin-left: 100px;
    position:relative;
    top: 20px;
}
</style>
<div id="test">
    <div id="test-in">分享到</div>
</div>    
<script>
test.onmouseover = function(){test.style.left = '0px';}
test.onmouseout = function(){test.style.left = '-100px';}
</script>

  [,<列名>
<数据类型>[列级完整性约束原则]]

移入移出

  如果把鼠标移入和鼠标移出都增加运动功能,则要以移动函数

  但是,有一个雅关键的题材亟需留意的是,鼠标移入移出的顺序问题

  如果拿转换入移有事件还加以在父元素的身上,则需做如下处理

  由于鼠标从子元素移动到父元素上常,会触发子元素的更换有事件,通过冒泡也会触发父元素移有事件。此时,有半点种植办法解决拖欠问题。一种是当子元素移有事件中阻止冒泡,另一样种植是在父元素移有事件设置target判断标准。当target为父元素本身时才实施

  鼠标从父元素移动至子元素的长河遭到,会遵循顺序触发父元素的易出事件、子元素的移入事件及父元素的移入事件

  为了避免接触移入事件。此时,使用开关变量对移入事件之代码进行限。移有事件代码完成前未实施移入事件代码

<script>
var testIn = document.getElementById('test-in');
var timer1,timer2;
var onOff = false;
test.onmouseover = function(){
    if(!onOff){    
        clearInterval(timer1);
        timer1 = setInterval(function(){
            if(!onOff){
                if(test.offsetLeft < 0){
                    test.style.left = test.offsetLeft + 10 + 'px';
                }else{
                    test.style.left = '0';
                    clearInterval(timer1);
                    timer1 = 0;
                }                    
            }else{
                clearInterval(timer1);
            }
        },30);
    }
}
test.onmouseout = function(e){
    e = e || event;
    var target = e.target || e.srcElement;
    if(target === test){
        //当触发父元素移出事件时,开启开关
        onOff = true;
        clearInterval(timer2);
        timer2 = setInterval(function(){
            if(test.offsetLeft > -100){
                test.style.left = test.offsetLeft - 10 + 'px';
            }else{
                test.style.left = '-100px';
                clearInterval(timer2);
                timer2 = 0;
                //当运动结束后,关闭开关
                onOff = false;
            }    
        },30);        
    }
}
</script>

     …

活动函数

  从地方的代码中,可以见到运动有的重代码较多,把运动封装为带动参数的函数更方便

<style>
#test{width: 100px;height: 100px;background-color:lightblue;text-align:center;position:absolute;top: 0;left: -100px;}    
#test-in{width: 30px;height: 60px;background-color: orange;margin-left: 100px;position:relative;top: 20px;}
</style>
<div id="test">
    <div id="test-in">分享到</div>
</div>    
<script>
var testIn = document.getElementById('test-in');
var timer;
test.onmouseover = function(){move(test,0,10);}
test.onmouseout = function(){move(test,-100,-10)}
function move(obj,target,speed){
    clearInterval(timer);
    timer = setInterval(function(){
        if((obj.offsetLeft - target)*speed < 0){
            obj.style.left = obj.offsetLeft + speed + 'px';
        }else{
            obj.style.left = target + 'px';
            clearInterval(timer);
            timer = 0;
        }                
    },16);        
}    
</script>

  由于不仅仅是left值可以做活动,其他性能(如width)也可以。所以,属性attr也应当参数提取出来

  这时就无法使用offset像样特性,而应采取算样式的兼容函数getCSS()

function getCSS(obj,style){
    if(window.getComputedStyle){
        return getComputedStyle(obj)[style];
    }
    return obj.currentStyle[style];
}   

function move(obj,attr,target,speed){
    clearInterval(timer);
    timer = setInterval(function(){
        var cur = parseInt(getCSS(obj,attr));
        if((cur - target)*speed < 0){
            obj.style.left = cur + speed + 'px';
        }else{
            obj.style.left = target + 'px';
            clearInterval(timer);
            timer = 0;
        }                
    },30);        
}

 

  [,表级完整性约束原则]);

透明度

  透明度凡一个于奇特之体制,因为IE8-浏览器不支持opacity,只能通过滤镜的道写成filter:alpha(opacity=透明值)

  但是,由于IE浏览器获取计算样式时,可以抱从定义样式,所以尽管opacity属性在IE8-浏览器无法生效,但是可落它们的值

  如果透明度做运动吧,则需要针对倒函数进行双重打包

  [注意]出于透明度事关小数计算,如0.07*100=>
7.000000000000001,所以需要为此Math.round()去掉尾巴

<style>
#test{width: 100px;height: 100px;background-color:lightblue;text-align:center;position:absolute;top: 0;left: 0;}    
#test-in{width: 30px;height: 60px;background-color: orange;margin-left: 100px;position:relative;top: 20px;}
</style>
<div id="test">
    <div id="test-in">分享到</div>
</div>    
<script>
var testIn = document.getElementById('test-in');
var timer;
test.onmouseover = function(){move(test,'opacity',0.1,-0.05);}
test.onmouseout = function(){move(test,'opacity',1,0.05)}
function getCSS(obj,style){
    if(window.getComputedStyle){
        return getComputedStyle(obj)[style];
    }
    return obj.currentStyle[style];
}   
function move(obj,attr,target,speed){
    clearInterval(timer);
    var cur;
    timer = setInterval(function(){
        if(attr == 'opacity'){
            cur = Math.round(getCSS(obj,attr)*100);
            if((cur - target*100)*speed < 0){
                obj.style.opacity = (cur + speed*100)/100;
                obj.style.filter = 'alpha(opacity=' + (cur + speed*100) + ')';
            }else{
                obj.style.opacity = target;
                obj.filter = 'alpha(opacity=' + target + ')';
                clearInterval(timer);
                timer = 0;
            }
        }else{
            cur = parseInt(getCSS(obj,attr));
            if((cur - target)*speed < 0){
                obj.style[attr] = cur + speed + 'px';
            }else{
                obj.style[attr] = target + 'px';
                clearInterval(timer);
                timer = 0;
            }    
        }

    },30);        
}    
</script>

如果完整性约束规范涉及到该表的大多个属于性列,则必须定义在表级上,否则既好定义在列级也得以定义在表级

多值

  如果一个素来多单价值同时活动时,像下这样直白调用move()函数是生题目的

move(test,'opacity',0.1,-0.05);
move(test,'left',-100,-1);

  因为函数里面定时器的变量timer是一个集体变量,当一个走停止时,会败定时器。这时别一个平移就是没有形成,定时器已经停止了,就无法继续运动了

  所以,合适的做法是以参数对象obj下面安装一个自定义属性timers,timers为一个缺损对象,然后用定时器返回值储存在timers对象下的attr属性中,此时星星点点个定时器不会见彼此干扰

<style>
#test{width: 100px;height: 100px;background-color: lightblue;text-align:center;position:absolute;top: 0;left: -100px;opacity:1;}    
#test-in{width: 30px;height: 60px;background-color: orange;margin-left: 100px;position:relative;top: 20px;}
</style>
<div id="test">
    <div id="test-in">分享到</div>
</div>    
<script>
test.onmouseover = function(){
    move(test,'opacity',0.1,-0.05);
    move(test,'left',0,10);
}
test.onmouseout = function(){
    move(test,'opacity',1,0.05);
    move(test,'left',-100,-10);
}
function getCSS(obj,style){
    if(window.getComputedStyle){
        return getComputedStyle(obj)[style];
    }
    return obj.currentStyle[style];
}   
function move(obj,attr,target,speed){
    if(!obj.timers){
        obj.timers = {};
    }
    clearInterval(obj.timers[attr]);
    var cur;
    obj.timers[attr] = setInterval(function(){
        if(attr == 'opacity'){
            cur = Math.round(getCSS(obj,attr)*100);
            if((cur - target*100)*speed < 0){
                obj.style.opacity = (cur + speed*100)/100;
                obj.style.filter = 'alpha(opacity=' + (cur + speed*100) + ')';
            }else{
                obj.style.opacity = target;
                obj.filter = 'alpha(opacity=' + target + ')';
                clearInterval(obj.timers[attr]);
                obj.timers[attr] = 0;
            }
        }else{
            cur = parseInt(getCSS(obj,attr));
            if((cur - target)*speed < 0){
                obj.style[attr] = cur + speed + 'px';
            }else{
                obj.style[attr] = target + 'px';
                clearInterval(obj.timers[attr]);
                obj.timers[attr] = 0;
            }    
        }        
    },30);        
}    
</script>

例句:

多物体

  如果当页面被产生多独元素以活动函数进行动。由于定时器返回值在不同因素不同属性被都非会见于影响。所以,上面的倒函数可以一直用

<style>
div{height: 100px;width: 100px;position: absolute;left: 0;}
#test1{background-color: pink;top: 40px;}
#test2{background-color: lightblue;top: 150px;}
</style>
<div id="test1">元素一</div>
<div id="test2">元素二</div>
<button id="btn">开始运动</button>
<button id="reset">还原</button>    
<script>
reset.onclick = function(){history.go();}
btn.onclick = function(){
    move(test1,'width',300,10);
    move(test1,'left',100,10);
    move(test2,'width',500,20);
    move(test2,'left',200,10);
}
function getCSS(obj,style){
    if(window.getComputedStyle){
        return getComputedStyle(obj)[style];
    }
    return obj.currentStyle[style];
}   
function move(obj,attr,target,speed){
    if(!obj.timers){
        obj.timers = {};
    }
    clearInterval(obj.timers[attr]);
    var cur;
    obj.timers[attr] = setInterval(function(){
        if(attr == 'opacity'){
            cur = Math.round(getCSS(obj,attr)*100);
            if((cur - target*100)*speed < 0){
                obj.style.opacity = (cur + speed*100)/100;
                obj.style.filter = 'alpha(opacity=' + (cur + speed*100) + ')';
            }else{
                obj.style.opacity = target;
                obj.filter = 'alpha(opacity=' + target + ')';
                clearInterval(obj.timers[attr]);
                obj.timers[attr] = 0;
            }
        }else{
            cur = parseInt(getCSS(obj,attr));
            if((cur - target)*speed < 0){
                obj.style[attr] = cur + speed + 'px';
            }else{
                obj.style[attr] = target + 'px';
                clearInterval(obj.timers[attr]);
                obj.timers[attr] = 0;
            }    
        }        
    },30);        
}    
</script>

列级约束

回调

  物体的大半只特性可能不是以活动,可能是一个性质运动得之后,另一个特性再倒。如果要做到这种需求,就用因此到回调函数

  以倒函数中,定时器停止时,再调用运动函数,就足以连续运动功能

<style>
div{height: 100px;width: 100px;position: absolute;left: 0;}
#test{background-color: pink;top: 40px;}
</style>
<div id="test">元素</div>
<button id="btn">开始运动</button>
<button id="reset">还原</button>    
<script>
reset.onclick = function(){history.go();}
btn.onclick = function(){
    move(test,'left',100,20,function(){
        move(test,'width',300,10)
    });
}
function getCSS(obj,style){
    if(window.getComputedStyle){
        return getComputedStyle(obj)[style];
    }
    return obj.currentStyle[style];
}   
function move(obj,attr,target,speed,fn){
    if(!obj.timers){obj.timers = {};}
    clearInterval(obj.timers[attr]);
    var cur;
    obj.timers[attr] = setInterval(function(){
        if(attr == 'opacity'){
            cur = Math.round(getCSS(obj,attr)*100);
            if((cur - target*100)*speed < 0){
                obj.style.opacity = (cur + speed*100)/100;
                obj.style.filter = 'alpha(opacity=' + (cur + speed*100) + ')';
            }else{
                obj.style.opacity = target;
                obj.filter = 'alpha(opacity=' + target + ')';
                clearInterval(obj.timers[attr]);
                obj.timers[attr] = 0;
                fn && fn.call(obj);
            }
        }else{
            cur = parseInt(getCSS(obj,attr));
            if((cur - target)*speed < 0){
                obj.style[attr] = cur + speed + 'px';
            }else{
                obj.style[attr] = target + 'px';
                clearInterval(obj.timers[attr]);
                obj.timers[attr] = 0;
                fn && fn.call(obj);
            }    
        }        
    },30);        
}    
</script>

create table student(

函数完善

【速度参数】

  上面封装的函数中,传递速度参数时,需要在快参数前续加正负号作为方向标识。实际上,这步可形容以函数的次外,而单独传递正之速度参数即可

speed = parseInt(getCSS(obj,attr)) < target ? speed : -speed;

【拉回操作】

  还有一个好升级之地方,就是关回操作。通过判断元素是否到目标点,如果超过目标点后,将元素拉回来目标点位置

cur = parseInt(getCSS(obj,attr));
if((cur - target)*speed < 0){
    obj.style[attr] = cur + speed + 'px';
}else{
    obj.style[attr] = target + 'px';
    clearInterval(obj.timers[attr]);
    obj.timers[attr] = 0;
    fn && fn.call(obj);
} 

  更客观的操作,应该是因素肯定不克过目标点

  所以应该把判断标准用来拍卖speed,当speed是一个适当的值经常,再赋值给obj.style[attr],可转移如下

cur = parseInt(getCSS(obj,attr));
//若速度设置值使得元素超过目标点时,将速度设置值更改为目标点值 - 当前值
if((cur +speed - target)*speed > 0){
    speed = target - cur;    
}
//将合适的speed值赋值给元素的样式
obj.style[attr] = cur + speed + 'px';

//当元素到达目标点后,停止定时器
if(speed == target - cur){
    clearInterval(obj.timers[attr]);
    obj.timers[attr] = 0;
    fn && fn.call(obj);    
}

【使用步长】

  其实,把元素的走变化命名也快并无相宜,只是因为约定俗成的关联才这么起名,将那个命名也宽度step更为恰当,定时器每运行一不善,该元素前越来越

 

id int identity(1,1) primary key,

Interval函数

  以move.js的名字对该运动函数进行封存,在线地址

function getCSS(obj,style){
    if(window.getComputedStyle){
        return getComputedStyle(obj)[style];
    }
    return obj.currentStyle[style];
} 
function move(obj,attr,target,step,fn){
    //如果没有建立定时器对象,则在obj下建立定时器对象
    if(!obj.timers){obj.timers = {};}
    //清除定时器
    clearInterval(obj.timers[attr]);
    //声明当前值变量cur
    var cur;
    //判断步长step的正负值
    step = parseInt(getCSS(obj,attr)) < target ? step : -step;
    //开启定时器
    obj.timers[attr] = setInterval(function(){
        //如果样式是透明度
        if(attr == 'opacity'){
            //对当前值的取值进行四舍五入,去除由于javascript小数计数中的bug存在的小尾巴
            cur = Math.round(getCSS(obj,attr)*100);
            if((cur - target*100)*step < 0){
                //设置透明度
                obj.style.opacity = (cur + step*100)/100;
                //IE兼容
                obj.style.filter = 'alpha(opacity=' + (cur + step*100) + ')';
            //透明度到达指定目标时
            }else{
                obj.style.opacity = target;
                obj.filter = 'alpha(opacity=' + target + ')';
                //清除定时器
                clearInterval(obj.timers[attr]);
                obj.timers[attr] = 0;
                //设置回调函数
                fn && fn.call(obj);
            }
        //当样式不是透明度时
        }else{
            //获取样式当前值并赋值给cur
            cur = parseFloat(getCSS(obj,attr));
            ////若步长设置值使得元素超过目标点时,将步长设置值更改为目标点值 - 当前值
            if((cur + step - target)*step > 0){
                step = target - cur;
            }
            //将合适的步长值赋值给元素的样式
            obj.style[attr] = cur + step + 'px';
            //当元素到达目标点后,停止定时器
            if(step == target - cur){
                clearInterval(obj.timers[attr]);
                obj.timers[attr] = 0;
                fn && fn.call(obj);    
            }
        }        
    },30);        
}  

【实例】

  下面坐一个实例来说明move函数的使用,点击document即可查看效果

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Document</title>
<style>
div{
    width: 50px;
    height: 50px;
    position: absolute;
    top: 0;
    background-color:lightblue;
}
div:nth-child(odd){
    background-color:pink;
}
</style>
</head>
<body>
<script src="http://files.cnblogs.com/files/xiaohuochai/move.js"></script>
<script>
var str = '';
var len = 10;
var timer;
var num = 0;
for(var i = 0; i < len; i++){
    str+= '<div style="left:'+60*i+'px;"></div>';
}
document.body.innerHTML = str;
document.onclick = function(){
    var aDiv = document.getElementsByTagName('div');
    if(timer) return;
    timer = setInterval(function(){
        move(aDiv[num++],'top', 200,10,function(){
            var _this = this;
            setTimeout(function(){
                move(_this,'top', 0,10);
            },1000)
        });
        if(num == len){
            clearInterval(timer);
            num = 0;
            setTimeout(function(){
                timer = 0;
            },2000);
        }
    },100);
}
</script>    
</body>
</html>

 

name varchar(20) not null,

Frame函数

  使用setInterval()的题目在于,定时器代码可能以代码再次被填补加至队之前还没水到渠成实施,结果造成定时器代码连续运行好几不善,而里面从来不其他停顿。而JS引擎对这个问题的缓解是:当使用setInterval()时,仅当没该定时器的旁其他代码实例时,才将定时器代码添加到行列中。这包了定时器代码加入到队中之最为小时间距离为指定间隔

  但是,这样会导致个别只问题:1、某些间隔为超越了;2、多个定时器的代码执行之间的距离或比预期的有些

  为了避免setInterval()定时器的问题,可以采取链式requestAnimationFrame()调用,IE9-浏览器可使用setTimeout()兼容

  以frameMove.js的名保存该js文件

if (!window.requestAnimationFrame) {
    requestAnimationFrame = function(fn) {
        setTimeout(fn, 17);
    };    
}
if (!window.cancelAnimationFrame) {
    window.cancelAnimationFrame = function(id) {
        clearTimeout(id);
    };
}
function getCSS(obj,style){
    if(window.getComputedStyle){
        return getComputedStyle(obj)[style];
    }
    return obj.currentStyle[style];
}   
function move(obj,attr,target,step,fn){
  //如果没有建立定时器对象,则在obj下建立定时器对象
  if(!obj.timers){
    obj.timers = {};
  }
  //清除定时器
  cancelAnimationFrame(obj.timers[attr]);
  //声明当前值变量cur
  var cur;
  //判断步长step的正负值
  step = parseInt(getCSS(obj,attr)) < target ? step : -step;  
  //开启定时器
  obj.timers[attr] = requestAnimationFrame(function func(){
    //如果样式是透明度
    if(attr == 'opacity'){
        //对当前值的取值进行四舍五入,去除由于javascript小数计数中的bug存在的小尾巴
        cur = Math.round(getCSS(obj,attr)*100);
        if((cur - target*100)*step < 0){
            //设置透明度
            obj.style.opacity = (cur + step*100)/100;
            //IE兼容
            obj.style.filter = 'alpha(opacity=' + (cur + step*100) + ')';
            //递归调用定时器
            obj.timers[attr] = requestAnimationFrame(func);
        //透明度到达指定目标时    
        }else{
            obj.style.opacity = target;
            obj.filter = 'alpha(opacity=' + target + ')';
            //清除定时器
            cancelAnimationFrame(obj.timers[attr]);
            obj.timers[attr] = 0;
            //设置回调函数
            fn && fn.call(obj);
        }
    //当样式不是透明度时    
    }else{         
      //获取样式当前值并赋值给cur
      cur = parseInt(getCSS(obj,attr));
      //若步长设置值使得元素超过目标点时,将步长设置值更改为目标点值 - 当前值
      if((cur + step - target)*step > 0){
          step = target - cur;
      }
      //将合适的步长值赋值给元素的样式
      obj.style[attr] = cur + step + 'px';
      //递归调用定时器
      obj.timers[attr] = requestAnimationFrame(func);
      //当元素到达目标点后,停止定时器
      if(step == target - cur){
        cancelAnimationFrame(obj.timers[attr]);
        obj.timers[attr] = 0;
        fn && fn.call(obj);        
      }
    }   
  });  
}  

 

sex  CHAR(2)

浏览器问题

  不论是Interval版本的倒函数,还是requestAnimationFrame版本的移位函数,语法都不曾问题。但浏览器也发生题目。为了厉行节约,对于那些无处在当前窗口的页面,浏览器会将时刻距离扩大至1000毫秒。另外,如果笔记本电脑处于电池供电状态,Chrome和IE10+浏览器,会用时刻间隔切换至系统定时器,大约是16.6毫秒

  定时器时间距离的变迁,得到运动不可知以预期进展,很多时光会见冒出预想不到的bug

  比如,还是点的例子,它是盖iframe内联框架的样式引入页面的。如果元素于移动过程被,拖动滚动条,使可视区域展示外内容。过几秒钟后,再转移回时,发现运动的因素就冒出了bug

起名 1

  关于以上气象的解决办法是,只要页面不处于活动状态,定时器就住运转,回到活动状态时,再回复运转。可以下window的onblur和onfocus事件来缓解

  window.onblur = function(){
    //清除定时器
    cancelAnimationFrame(timer);
  }
  window.onfocus = function(){
    //开启定时器
    timer = requestAnimationFrame(func)
  }

  [注意]不得不用window.onblur的款式,而休克使用window.addEventListener的款型  

  但是,当起多个定时器时,此题材仍旧不好解决。更好之法是使日子本运动

 

)

表级约束:Constraint为束缚起名

CREATE TABLE Student

(Sno  CHAR(9) ,

Sname  varchar(20) ,

Ssex  CHAR(2) ,

Sage  SMALLINT,

Constraint PK_S PRIMARY KEY(Sno)

);

CREATE TABLE SC

           (Sno   CHAR(9)  NOT NULL,

            Cno  CHAR(4)  NOT NULL, 

            Grade    INT,

Constraint PK_SC PRIMARY KEY (Sno,Cno)

);

列级unique约束

CREATE TABLE Student (

    Sno   CHAR(9) PRIMARY KEY,

    Sname VARCHAR(20) Constraint UQ_s_sname UNIQUE,

    Ssex    CHAR(2),  Sage   SMALLINT,

Sdept  CHAR(15)

);

 

CREATE TABLE Student

        (Sno  CHAR(9) PRIMARY KEY,

          Sname varchar(20) NOT NULL,                    

          Ssex  CHAR(2) ,               

          Sage  SMALLINT,

          Sdept  CHAR(15) ,

          UNIQUE(Sname),

          CHECK (Ssex IN (‘男’,‘女’) )

);

 

CREATE TABLE  Course

 (     Cno  char(4) ,

        Cname  varchar(40),           

        Cpno  char(4)  REFERENCES  Course(Cno) ,

        Ccredit  int,

        Primary Key(Cno)

 );

CREATE TABLE  SC

       (Sno  CHAR(9) REFERENCES Student(Sno) ,

       Cno  CHAR(4), 

       Grade INT DEFAULT 0,

       PRIMARY KEY (Sno,Cno), 

Constraint FK_sc_cno  foreign key (cno) references course(cno)

);

 二、约束类型

(1) PRIMARY KEY约束

(2)NULL/NOT NULL约束

(3)UNIQUE约束

(4) CHECK完整性约束

         检查字段值所兴的限定

(5) FOREIGN KEY约束

(6)DEFAULT 约束

         
如果用户在插入新行时没有显得也列提供数据,系统将默认值赋给该列

 

老三、数据类型:

SQL中域的概念用数据类型来促成

数据类型

含义

CHAR(n)

长度为n的定长字符串

VARCHAR(n)

最大长度为n的变长字符串

INT

长整数(也可以写作INTEGER)

SMALLINT

短整数

NUMERIC(p,d)

定点数,由p位数字(不包括符号、小数点)组成,小数后面有d位数字

REAL

取决于机器精度的浮点数

Double Precision

取决于机器精度的双精度浮点数

FLOAT(n)

浮点数,精度至少为n位数字

DATE

日期,包含年、月、日,格式为YYYY-MM-DD

TIME

时间,包含一日的时、分、秒,格式为HH:MM:SS

 

季、修改基本表

ALTER TABLE <表名>

    [ADD
<新列名><数据类型>[ <完整性约束定义]]

    [ ADD  <表级完整性约束>
]

    [ ALTER COLUMN<列名>
<数据类型> ]]

    [ DROP <完整性约束定义>
];

  • 注意:

1.
运ADD方式多的新列自动填写充NULL值,所以当表中生出数量常常长的新列不克指定NOT
NULL约束

例句:

于Student表增加“入学时”列,其数据类型为日期型。

 ALTER TABLE Student ADD S_entrance
Datetime;  //加列

ALTER TABLE Student ALTER COLUMN Sage
INT;   //修改列

ALTER TABLE Course ADD UNIQUE(Cname);    
 //加约束

  • 说明中来数据时:

      Alter Table student ADD scome
date default to_date(‘2008-01-01′,’yyyy-mm-dd’);

 

五、删除基本表

DROP TABLE <表名>[RESTRICT|
CASCADE];

 1) RESTRICT:删除表是有限量的。

  • 待删除的基本表不可知让其他表底律所引述
  • 若果有依靠该表的靶子,则是说明不可知给删去

 2)
 CASCADE:删除该表没有限定。

  • 在剔除基本表的而,相关的凭对象同去

例句:

DROP TABLE  Student  CASCADE ;

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图