php+mysql等等的杂货

三元运算符的使用
先执行
执行完毕过后
这句话为真
90
hello
我的建议
就说这种代码
用括弧括起来。提高可读性
使用细节
三元运算符的表达式可以是函数返回的值
function geiSum($num1,$num2) {
    return $num1 + $num2;
}


三元运算符的经典用法，用于判断获取的数据是否存在
类型运算符、
用于确定变量是否是某一对象的实例
创建一个Dog类的对象实例
不是对象实例
单例模式
单例模式
执行运算符，要注意系统的跨平台问题
execute
echo '<pre>';
echo `netstat -anb`;
我都懵逼了
当我们进行运算时，需要搞清楚。各个运算符的优先级
运算符的优先说明
php基础加强之流程控制
默认从上而下执行
顺序控制
分支控制
基本介绍
概念
让程序有选择的执行
if
上什么网站呢
$age = 20;
if ($age > 18) {
    echo '你年龄大于18岁，要对自己的行为负责哦';

}
画出该程序对应的流程图
if的替换语法：if : endif
双分支的替代语法
switch
递增递减
判断值是否相等
如果值不相等或者类型不相等
逻辑与逻辑或
常用运算符的优先级高低
switch：判断某一变量是否属于某一值
如何使用if和switch
当我们判读的情况是几个具体 的值时我们选择switch效率较高
当我们判断的情况是一个范围的时候，我们选择用if
循环控制
for循环：循环初值，循环条件，增量
$i,$j,$k
代码，内存（代码运行的空间）
对应的流程图保存一下保存到这里
for($i = 100, $j = 0; $j <10 ; $j++) {
    echo $i,$j,'<br>';
}
for循环允许有空余存在
for循环讲解的第一部分
while循环
循环控制变量
流程图
还不还钱
打印金字塔
层数乘2减1
当你打的一层的时候
等于一i是你当前层数
全角空格
牛逼顺平
表示总层数
break语句加强
代码说明
0 1
1 1
基本介绍goto
代码说明：
语句块
对应流程图
代码截取到相应位置
关于goto的使用事项：
只能在同一个文件或作用域中跳转
也无法跳到另一函数
退出while循环的条件是不够交路费
php基础加强，常量
基本介绍：为什么需要常量，什么时候可能用的
const
计算某人的所得税
定义所得税的税率
$salary = 10000;
常量的命名规范是字母大写加下划线
魔术常量
__LINE__：显示当前是第几行
可变变量
$a = 'hello ，泰牛';
$b = 'ok，你好';
$var = 'a';
echo $$var;
计算机
爽
目的
把我们学习过的变量和控制结构整合到一起
能够完成简单的前台验证和后台验证
1.接收用户提交的数据，并验证数据的合法性
2.在前端，用户提交数据时，规范要求对提交的数据使用js进行数据验证
走代码
//编写js的函数
//获取用户输入的num1和num2
isNaN,不是数返回真
该页面不再运行。提高效率
运算时强制转义
//初始化一个变量
php函数基础加强
php有多少函数
为什么需要函数
提高代码复用性
利于模块化编程
扩展性好
function jisuan($num1,$num2,$oper){
    ....
}

require 'mufun.php';
我下面给你吃
截断视频
18:20
18：28
函数的概念和分类
一般来讲100行以内
形参：不确定的参数，给啥是啥
实参：实际传递的参数
不理解就背过
return:业务逻辑决定
函数的基本语法是:
文件引入的基本使用：四种方式
绝对路径与相对路径
require include

5.23
自习中

5.24
课程回顾
while循环
循环打金字塔
goto a (label)
常量
const SS=‘’
define（SS,''）;
预定义常量
魔术常量8个
__FILE__，__DIR__
变量名，常量名，函数名细节
累觉不爱
心酸
欲速则不达
文件引用的四种基本方式
退出
include
require require_once
网线玩坏了
关于引用文件的流程细节说明
先将引入文件的结果计算得出，再执行引用
当我们引入的文件含有return时，return到底有什么用
在项目开发中，文件引用的使用方法
网站结构
-----css文件夹
    -----css文件
-----js文件夹
    ------js代码，jquery框架
-----img图片文件夹
    -----1.jpg
-----templates模版文件
    -----mytemplate.html
-----lib 文件夹（常用的自定义函数库，初始化文件init.php）
    -----function.php
    -----init.php
-----index.php 入口文件（怎么使用）

引用用绝对路径

init.php
//获取到网站的根目录
define('ROOT_PATH',dirname（__DIR__）.'/');

//把模版的绝对路径获取到
define('TEMPLATE_PATH',ROOT_PATH.'template/');

//定义lib的绝对路径
define('TEMPLATE_PATH',ROOT_PATH.'lib/');

//。。。以此类推

//引入function.php
...

函数的理解
函数运行的原理说明
内存的分区
----代码区
----数据区
----栈区（程序运行的区间）
    --主栈
    --新栈
1.当调用一个函数时，会在内存种开辟一个新栈
2.当函数return时，会把结果返回给调用处
3.当我们的函数调用完毕后（比如return或正常执行完毕），
  该栈就会被销毁，也就是全局与局部的一个区别

函数的递归调用：
基本概念：函数在内部再调用自

函数的细节
1.函数的参数列表可以是多个，数据类型可以是任意类型

戒辣，一个礼拜

global本质相等与地址符&（值传递）
global $a  == $a=&$GLOBALS['a']
static: 只会初始化一次，不会马上销毁，存放在静态数据区
函数传递参数的说明
栈区
主栈，新栈
引用传递和值传递
会叫的狗不咬人
unset 仅仅是把变量本身给干掉了，没有销毁值
基础很重要
内部函数（了解）
calculator
可变函数
function abc($n1,$n2) {
    echo $n1+$n2;
}
abc(10,20);
$a = 'abc';
$a(10.20);

函数的参数可以是另外一个函数
function fun($a,$b) {
    return $a+$b;
}
function getVal($a,$b,$fun) {
    echo    $fun($a,$b);    
}

getVal(1,2,'fun');

//匿名函数
匿名函数就是没有名字的函数
$fun1 = function ($n1 , $n2) {
    return $n1 + $n2 ;    
};

echo $fun1 (1 , 20) ;

5.25
文件间的多层引用关系
方法，函数
递归渔夫打鱼
function handling函数
当你疲倦的时候就休息下，撸下代码吧
懵逼的一天
数组的使用
一定要养成良好的代码书写习惯
路径名不要用下划线。优先用横线
外面更不干净
索引数组的下标值的增长是当前值加一
数组的遍历
 变量名尽量粘贴

数组的相关函数
sort
usort
array_merge //合并数组
array_reverse //反转数组单元
array_search
array_pop //出栈,弹出数组最后一个单元，数组本身变化
array_push //入栈,将单元加到数组尾部

!!!!!!usort 进行字符串长度的排序（已练习）

数组的运算符
+ 键相等，自动忽略，不会覆盖已经有的键

算法：内部排序
数组的排序：将一组数据，以指定的顺序进行排列的过程
交换式排序
--冒泡排序法    
    $arr = array(10,7,1);//从小到大的排序
    function bubble(&$arr) {
        $flag = 0;
        //先确定数组的大小
        $arr_size = count($arr);
        //确定大循环次数
        for ($i = 0 ; $i < $arr_size - 1 ; $i++) {
            for($j = 0 ; $j < $arr_size - 1 - $i ; $j++) {
                if($arr[$j] > $arr[$j+1]) {
                    //交换,定义一个中间变量
                    $temp = $arr[$j];
                    $arr[$j] = $arr[$j + 1];
                    $arr[$j + 1] = $temp;
                    $flag =1;
                }
            }
            //优化
            if ($flag == 0) {
                break;
            }else {
                $flag =0;
            }
        }
    }

--选择排序法

$arr = array (10 , 7, 1) ;
    function selectSort(&$arr) {
    //获取数组的大小
    $arr_size = count ($arr);
    //大循环
    for ($i = 0 ; $i < $arr_size - 1 ; $i++) {
        //假设$arr[$i] 就是最小值
        $min_val = $arr[$i];
        //最小值下标
        $min_val_index = $i;
        //循环，找真正的最小值
        for ($j = $i+1 ;$j < $arr_size ;$j++) {
            //判断
            if($min_val > $arr[$j]){
                //重新设置最小值好和下标
                $min_val = $arr[$j];
                $min_val_index = $j;
            }
        }
        //交换位置
        if($min_val != $arr[$i]){
            $arr[$min_val_index] = $arr[$i];
            $arr[$i] = $min_val;
        }
    }
}

查找
--顺序查找
--二分法查找：首先必须是一个有序的数组
首先找到中间数，和你要查找的数进行比较
$arr = array(1,2,3,56,81,121,545,887);
function binarySearch($left_index,$right_index,$arr,$find_value) {
    if($left_index > $right_index) {
        echo '找不到';
        exit;
    }
    //找到中间的下标
    $middle_index = round(($left_index+$right_index)/2);

    if($arr[$middle_index] == $find_value) {
        echo '找到了，下标为',$middle_index;
    }elseif($arr[$middle_index] >  $find_value) {
        binarySearch($left_index,$middle_index - 1 ,$arr,$find_value);
    }elseif($arr[$middle_index] < $find_value) {
        binarySearch($middle_index+1,$right_index ,$arr,$find_value);
    }
}

二进制中。0表正数，1表负数
位运算
echo ~2;//位取反 -3

5.27
编程最关键是要有长期的学习能力，始终保持向上的源动力
!!!!下一步的学习计划
保证日常学习的前提下，做一些项目
逐步提升代码量与编程思想，熟悉常用英文单词
逐步增加linux的知识。
以上
????按usort函数的运行模式，写一个自己的usort
，排序规律是冒泡法

插入排序法
$arr = array(10,7,1);
function insertSort(&$arr){
    
    //确定大循环次数
    $arr_size = count($arr);
    //从$i = 1这个数开始，插入到我们的有序数组
    for($i = 1 ; $i < $arr_size ; $i++) {
        //保存$arr[$i]值
        $insertVal = $arr[$i];
        //$index 是你的有序数组的最后一个元素的下标
        $index = $i -1;
        while($index >= 0 && $arr[$index] >$insertVal ) {
            //将$index对应的元素后移
            $arr[$index+1] = $arr[$index];
            $index--;
        }
        //将$insertVal值放入到 $index+1的位置
        $arr[$index + 1] = $insertVal;
    }
}

//快速排序法

面向对象编程
成员属性
创建对象
$cat = new Cat;
$cat ->age = 9;
 成员方法
 构造函数__construct:
没有返回值
实例化对象时，自动调用构造方法，完成初始化
一个类只能有一个构造函数
知识体系更完整
this：是典型的执行环境，谁调用就是指向谁的执行环境
析构函数：destruct（php5和__construct一起中加入）
主要作用是释放对方分配的相关资源，如数据库连接
触发：
1.程序运行结束后
2.实例化对象没有被变量指向，对象会被销毁，触发析构
默认情况下，先创建的对象后销毁，后创建的对象先销毁
最佳实践：
1.希望在程序没有结束前，销毁某个对象实例（实例对象使用完毕，直接置为null，可以及时释放重量级资源）
2.销毁对象创建的连接

php垃圾回收机制：
1.没有引用指向它
2.退出时自动销毁

5.28
面向对象编程，使用方便，编对象麻烦，怎么真特么的跟对象似的
代码量1w是个坎，10w又是一个坎

魔术方法：在满足某种情况下，魔术方法会被调用
访问修饰符：public protected private
__get __set:
__isset __unset:
clone :对象标识符不一样
当我们克隆时。会触发__clone 魔术方法
主要是为了单例模式中，不让clone 对象(给__clone 加上private)
__call:通常情况下，call用的不多
 
 !!!!需要加强匿名函数的知识。撸手册

 类的自动加载
 __autoload ,优化。做一个映射数组。来完成自动加载

静态属性 static
访问 类内部--self：：静态属性名
    类外部-- 类名：：静态属性名（要求静态属性是public）
注意事项：静态变量初始化和在类外的访问，不依赖于是否实例化对象

静态方法 不能访问非静态属性


5.30
单例模式：操作数据库的类，控制它只有一个对象实例

//传统思维
class DBHelper{
    
    //$conn是一个数据库连接
    private $conn;
    
    function __consttruct(){
        $this -> conn = @mysql_connect('localhost' , 'root' , 'root');
    }

    function query($sql) {
        echo '操作数据库';
    }
}

// 单例模式思维

class DBHelper{
    
    //$conn是一个数据库连接
    private $conn;
    //定义一个静态属性 , 表示一个DBhelper 实例
    private static $instance = null;

    private function __consttruct(){
        $this -> conn = @mysql_connect('localhost' , 'root' , 'root');
    }
    
    //静态方法,通过该方法。可以获得一个对象实例
    public static function getSingleton() {
        
            //第一种写法
            if (self:: $instance == null) {
                //实例化一个对象
                self::$instancr = new DBHelper();
            }
            return self: $nstance;

            //防止克隆，将__clone 做成私有的
            private function __clone(){};

            //第二种写法
            if(!(self :: $instance instanceof self) ) {
                self ::＄instance = new self();
            }
            return self :: $instance;
            
    }

    function query($sql) {
        echo '操作数据库';
    }
}

面向对象三大特征：封装，继承，多态
封装的实现：访问控制修饰符来控制方法和属性的访问权限

对象运算符的连续使用现象

//学生类
class Student{

    public $name;
    private $school;

    public function setSchool($school) {
        $this -> school = $school;
    }

    public function getSchool() {
        return $this -> school;
    }
}

//学校类
class School {

    public $name;
    protected $address;
    private $my_class;

    public function setClass($class) {
        $this ->class = $class;
    }

    public function getClass(){
        return $this -> class;
    }
}

//班级类
class MyClass {

    public $name;
    public $class_num;

}

$my_class = new MyClass();
$my_class -> name = 'php大牛二期班';
$my_class -> class_num = 108;

$my_school = new School();
$my_school -> name = '泰牛程序员' ;
$my_school -> setClass( $my_class ) ;

$my_student = new Student();
$my_student -> name = '倪增超' ;

$my_student -> setSchool($my_school);

//如果我们希望查看$my_student 的班级信息
echo '倪增超所在的班级名称是' , $my_student -> getSchool() -> getClass() ->name

继承：子类最多继承一个父类
    不能继承private
    在创建子类对象时，默认会调用父类的构造函数（子类没有定义构造函数，如果有，则会重写）
    子类中使用父类的方法      父类 ：：方法名（parent : : 方法名 || $this -> 方法名）    
    如果子类的方法名与父类的方法名相同。我们称为方法的重写

5.31
属性的重载：
//私有的数组，管理我们的重载属性
private $pro_array = array();

//写一个方法，来管理动态增长的属性
function __set($pro_name , $val){
    $this -> pro_array[$pro_name] = $val;
}

//写一个方法，返回你动态的属性
function __get($pro_name) {
    if(isset($this -> pro_array[$pro_name])) {
        return $this -> pro_array[$pro_name];
    }else {
        echo ‘重载的属性不存在’;
    }
}

重载的属性,当你调用是会触发__get ,定义的属性则不会

重写override
父类的方法在某些情况下无法确认，在该方法可能被子类覆盖（重写）
方法重写的细节
1.如果子类需要访问父类的方法（子类已覆盖父类方法），则用 parent :: 方法 或是 父类名::方法
2.访问父类静态属性，parent :: 属性
3.访问父类普通属性 $this -> 属性
4.重写方法的时候。要求方法的函数名，参数个数一样才成功
5. 如果父类的方法使用了类型约束，子类也需要有类型约束且必须和父类约束一致
6.子类方法不能缩小父类方法的访问权限

类型约束 php5 以后 ,callable php5.4以后
class Dog{
    function test(Dog $dog , array $arr , callable $func) {
        echo '<pre>';
        var_dump($dog);
    }
}

class Cat{
    
}

test('abc' , array(1,2) , function { echo 'hello' ;});
$cat = new Cat;
test($cat);

属性的重写

多态：通俗讲就是类的多种状态
1.可以根据传入的对象类型不同，调用对应该对象的方法
2.php天生就是多态语言
重载是多态的一种表现形式

抽象类：把不能确定的方法或属性抽象出来，单独做一个类，通过继承的方法给子类使用，就是抽象类
抽象方法：方法拿 abstract 修饰，不能包含方法体（不带大括号），必须放在抽象类中
1.如果一个类中，只要包含一个抽象方法，则该类必须声明为abstract
2.抽象类重点主是为了设计（规范），让其他类来继承并实现它的方法
细节说明：
1.抽象类不能被实例化
2.抽象类可以没有抽象方法
3.抽象类可有非抽象方法，成员属性和常量（只能const声明）
4.只要包含一个抽象方法，则该类必须声明为abstract
5.抽象方法不能有方法体
6.如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，
   除非他自己也声明为抽象类。

接口：给出一些没有实现的方法，封装到一起，到某个类使用时，再根据情况将方法写出来
--可以理解为更加抽象的抽象类，接口里的所有方法都没有方法体。体现了程序设计的多态个高内聚低耦合的设计思想
interface 接口名 {
    方法（）;
}
接口的命名规范，小写 i 打头，后边用驼峰法
接口的价值在与设计，让别的类来实现它声明的方法
接口实现 : class 类名 implements 接口名 {}
细节：
1.接口不能实例化
2.接口中方法都不能有主体（都是抽象方法），没有必要用abstract修饰
3.一个类可以实现多个接口，逗号隔开
4.接口中的属性只能是常量 ，默认是public ，但不能写public。使用：接口名：：常量名
5.接口的方法必须全是public
6.接口不能继承别的类，可以继承别的接口
接口是在不破坏单继承结构的基础上，对子类方法的补充完善。
即插即用，方便灵活

final关键字 ：父类的方法声明final ，则无法被重写，
              类被声明final ，则无法被继承。(单例模式破继承)
细节：
1.不能修饰属性
2.final 方法不能重写，但可以被继承
3.final 类中不需要写final方法，太水。
4.final 类可以被实例化


6.02

类常量:const 常量名:值
使用细节:
1.命名规范遵循常量规范
2.定义时就赋值,且定义后不能修改
3.不能带访问修饰符
4.访问
    类外部: 类名::常量名    接口名::常量名
    类内部: 类名::常量名    self::常量名
5.可以被继承
6.常量属于一个类,而不是一个对象(不能用$this访问)
7.数据类型可以是标量与数组和null

对象克隆技术:
$新对象 = clone $旧对象

对象(属性)遍历:
foreach($对象 as $key => $val){}
对象外遍历,只能遍历到public属性

php内置标准类 stdClass,不需要创建就能使用
通常用它以对象的形式管理数据

其他数据类型转对象
我们在某些情况下,需要把其他的数据类型转成对象形式
$test = array ('no1' => '宋江' , 'no2' => '卢俊义');
$test_obj = (object) $test;
var_dump($test_obj);
1.关联数组转对象 转成了内置标准类(stdClass)的一个对象实例
2.不要用索引数组

对象当字符串使用

对象序列化 :把一个对象的属性名称,属性的类型和值都保存到文件中
还可以反序列化,把对象重新恢复.
使用情况:
1.当我们编写大项目时,需要将一个对象的数据和类型,保存到文件中,
便于调试,就会用到对象序列化技术
2.把一个对象放在session中.
细节;
1.如果我们要把一个对象反序列化,则要把该类的定义引入进来.

类与对象相关函数
class_exists('类名') :判断类存不存在,其后可以再实例化一个对象
method_exists('对象','方法名') : 判断方法存不存在
property_exists('类名','属性名') : 判断属性存不存在
get_class('对象')  :当前对象对应的类名

trait: 解决类似php这种单继承语言的代码复用性问题
trait 名字 {
    方法
}
使用:
class a {
    use trait名字;
}
trait 不能被实例化
优先级问题 : 如果父类和trait 有相同的方法时,会怎么处理
以 trait 里的方法为准

反射机制
使用场景:
1.底层框架
2.扩展功能
3.管理大量的未知类
reflection 的基本原理和机制
RflectionClass::export('类名') : 反射机制,查看类的结构
反射的代理调用
1.获取一个test类的反射类对象
$test_reflect_class = new ReflectionClass('test');
2.通过反射类对象,得到实例
$test = $test_reflect_class -> newInstance('大狗' ,10);
3.获取反射方法的对象实例
$dog_cry_method = $test_reflect_class ->getMethod('cry');
4.通过方法反向调用
$dog_cry_method -> invoke($test , '哇哇叫');


MYSQL进阶

mysql 基本使用
cmd > mysql  -h 主机 -u 用户名 -p 密码


6.3
数据库相关操作
显示数据库 : show databases;
显示数据库创建语句 : show create database 名字
--  ``反引号可以避免你使用的库名刚好是关键字而不能使用.
删除数据库 : drop database 名字;

如何备份 , 恢复数据库
cmd>mysqldump -u -p 数据库>数据库导向路径
恢复数据库,要进入到mysql管理控制台
1.创建一个空数据库
2.use 新数据库
3.导入信息
source 备份的路径
细节:
--备份某一张表
cmd>mysqldump -u -p 数据库 表1 表2 表3 > 备份的导向路径
--在恢复数据时,必须使用对应的数据库(如果是-B备份数据库,则可以不用建库和use)
--备份多个数据库
cmd > mysqldump -u -p -B 库1 库2 库3
source 多个数据库备份的路径

数据库的修改
alter database 数据库 [字符集,校验规格]

创建表
create table 表名(表结构) [字符集,校验规格,存储引擎];
不同的存储引擎, 创建表的文件不一样
--MyISAM 一个表会产生三个文件
--InnoDB 一个表会产生一个文件,剩下的数据统一存在一个公用的文件

mysql常用数据类型
数值类型 : 整数
--tinyint 2的7次方-1 至-2的7次方(减去一位符号位)       
   tinyint 1个字符占1个字节(byte),一个字节(byte) 有8位(bit)  负数比正数多一位,因为加上了一个负零(10000000)
--bit 位字段类型  bit(m) m表示每个值的位数,默认是1 范围1-64
    bit使用注意事项:
        1,是按ascii 显示
        2.如果我们有这样的值,只存放0 和 1,bit就有价值 --bit(1)  查询时0为空,1为'笑脸'
细节:
  1.mysql中,数值可以指定为有无符号,默认有符号.(unsigned指定为无符号)
  2.数值型 int(6) 代表什么
    --int(6) 需要跟zerofill配合,单独使用没有意义,,如果不够6位,则拿0填充
      超过6位有多少存多少.直到数值的最大限制值
      只要指定了zerofill 则默认就是unsigned.

数值类型 : 小数
--float(4,2)  范围 -99.99 到 99.99     unsigned 0 到 99.99 ,精度大约在7位小数
--double 精度大约在15位
--decimal(4,2)     范围 -99.99 到 99.99  ,小数位不够,拿0 填充  整数位最大范围位65位.小数位30位
    decimal 没规定范围,则默认是decimal(10,0)
--decimal 精度高于 float , 如果数据表示高精度,用decimal  

文本和二进制类型 :
--char(字符数) : 固定长度字符串 ,最大255字符, 位数不满拿空格填充,
--varchar(字符数) : 可变长度字符串 , 有效最大65532 字节(理论65535,1-3个字节用来记录数据大小),utf8下存放21844 字符,
--text 保存文章,留言等,特别注意 , 不能有default
查询速度 :　char > varchar
 --补充说明 , 表的所有字段长度最大为65535字节.
    即 create table text(id int , varchar(21844)) charset=utf8;   这会报错--int 一个字符 4个字节 , varchar utf 8 下 3个字节 . 4+(21844*3 + 3) > 65535

时间日期类型
timestamp 时间戳 : 在insert 和 update 时 , 自动联动

string型
enum和set
支持插入数字作为值.enum分别是1 , 2, 3, 4 ....
set 分别是 1 , 2, 4, 8, 16......
细节: set 查询时 用 find_in_set   select * from test1 where find_in_set('篮球',hobby);



6.5日..马上就放端午假了吧
数据库挂掉,把数据库备份了下.重新装了环境,但是
没有将www下的文件备份,所有服务器里存的资料丢失
!!!!!!!!!!!!!!!!!!!!一定要记得备份数据库,服务器,各种配置文件等等等等!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

修改表(重点): alter语句
添加字段 :　alter table 表 add  字段 字段定义...after 某字段
修改字段 :　alter table 表 modify 字段 字段定义 ..... after 某字段
删除字段 :　atter table 表 drop 字段
修改表名 :　alter table 表 rename to  新表名
修改字符集: alter table 表  charset = utf8;
修改字段名(同时修改定义): alter table 表 change 原字段 新字段  字段定义

表crud语句:

插入数据
insert into 表[字段] values(值1,值2,) , (值1 , 值2)...;
细节:
1. 插入数据类型要和字段类型相同
2. 数据的大小要符合字段的限制条件
3. 插入数据的顺序要与字段的顺序一致
4. 字符,日期类型要包含在单引号中
5. 插入空  不指定或值1为 null
6. 可以一条语句添加多条记录
7. 所有的插入的值都可以用单引号包起来

更新数据
update 表 set 字段  = 值(或表达式), 字段 = 值 where 条件;

删除数据
delete from 表 where ....;
truncate table 表
区别:
1. truncate 删除速度快
2. delete 可以指定删除,更灵活
3. truncate 删除返回0 , delete会返回删除的条数细节
4. delete 删除全部数据,表结构还在

细节
1.delete 不使用where 会删除所有数据
2.delete 不能删除某一字段的值,可以用update 设为null 或'';

在练习删除时 , 可以复制一份表以用来练习
--复制一份表结构
create table test2 like test1;
--复制表数据
insert into test2 select * from test1;

查询表
select [distinct] * from 表
distinct 可以剔除掉相同数据

对列进行运算和别名操作
//查询姓韩的学生的总分
mysql> select name,(chinese+english+math) as '总分' from student1 where name like '韩%';

where 字句的使用
select name,math,chinese,english, math+ chinese+english as '总分' from student1 where (math+english+chinese)>200 and name like '宋%'and math<chinese or name like '韩%';
查询之间的条件
between ...and....
在某一条件内查询
...in(值1,值2,值3)

order by 排序子句的使用
order by 排序的字段 asc(升序)|desc( 降序)      默认asc
select name,math+chinese+english as '总分' from student1 order by 总分;
注意:如果对别名排序,别名不要带引号


6.6 大顺

count函数
select count( * || 字段) from 表 [where....];
count(*) 与 count(字段) 的区别
count(字段) 不会统计为 null 的数据

sum函数
返回满足where条件的 列的和
select sum(列名1),.... form table where....;
注意: sum 只能对数值起作用 ,不统计为 null 的数值

avg函数
返回满足where 条件的 列的平均值.
select avg(列名1),.....from table where....
注意:avg 不统计为 null 的数值

max,min函数
返回满足 where 条件的列的最大值或最小值
select max(列名) from 表 where...;

group by 分组字句
对列进行分组
select column1,column2,...from 表 group by column

having 字句
和 group by 配合使用,对group by 结果进行过滤
select avg(sal) as '平均工资',deptno from emp group by deptno having 平均工资 < 2000;


函数
日期时间函数
参看手册.必须熟练运用

字符串函数
参考手册

数学函数

流程控制函数

多表查询


6.08 明天端午节,今两天的课只上一天就放假

子查询(嵌套查询)
单行子查询 : 返回一行数据的子查询语句
多行子查询 : 但会多行数据的子查询语句

重点 : 子查询结果不仅仅可以当作 where 条件.也可以将结果(如排序操作)看成是一张临时表来使用
如  select * from (select cat_id,goods_name, shop_price from ecs_goods order by cat_id,shop_price desc) as temp group by temp.cat_id;

all 关键字
select  * from emp where sal > all(select sal from emp where deptno = 30);//大于所有
select  * from emp  where sal >(select max(sal) from emp where deptno = 30); //大于最高

any 关键字
select  * from emp where sal > any(select sal from emp where deptno = 30);//大于任意一个
select  * from emp  where sal >(select min(sal) from emp where deptno = 30); //大于最低

多列子查询详解
 select * from test2 where (language_point,match_point,english_point) = (select language_point,match_point,english_point from test2 where name = '关羽');

在from语句中使用 子查询

自我复制(蠕虫复制)

合并查询 union ,union all
union 合并几个sal 语句结果集,并去掉重复数据    union all 会保留重复的数据
select ename,sal,job  from emp where sal >2500 union
select ename,sal,job  from emp where job = 'manager';

内连接和外连接

内连接基本语法 :
select  ... from 表名1 inner join 表名2 on 连接条件   and 连接条件
 select emp.ename,dept.dname from emp inner join dept on emp.deptno = dept.deptno;

 外连接分类
 左外连接 : 如果左侧的表完全显示就是左外连接
 右外连接 : 如果右侧的表完全显示就是右外连接
 基本语法 : select .. from 表名1 left join 表名2 on  ......

表的约束 :
项目开发中,我们要对表的数据进行管理(比如从业务逻辑的角度保证数据的正确性),
对了达到这个效果,mysql 提供了一种机制,来保证这些数据的正确性
约束有5种 : primary key(主键) ,not null(非空),unique(唯一), 外键约束(foreign key),check(在mysql 支持语法,但本身不起作用)

主键约束 :
1. 主键不能重复和为null
2. 一张表中只能有一个主键,但可以是复合主键  primary key (id,name);
3. 一般来说每张表都会有主键,而且是整数型
4. 两种使用方法   id......primary key       primary key(id)
5. not null + unique 使用效果上约相等于 primary key
6. desc  和 show create 可以查看主键

非空约束 :
一般是和dafault 0('')配合使用

唯一约束
1. 只能有一个主键 , 可以有多个唯一
2. 可以为null ,也可以插入多个null值
3. 添加not null ,则可以禁止以上效果

外键 foreign key
基本语法 : foreign key (本表字段名) references 主键表名 (主键名 或 unique 字段)
细节 :
1. 外键指向表的字段,要求是key 或 unique
2. 表的引擎类型须是 innodb ,才支持外键
3. 主键和外健的字段类型要保持一致
4. 外键字段的值,必须在主键字段值中出现过 ,(不设not null .外键可以指定为 null)
5. 不能删除被使用中的主键的值(或主键表自身)
6. 不指定外键,则需数据库程序员自己维护.

check约束(orcal 和sqlserver 均支持check,mysql 支持语法,但无效果)
用于强制行数据必须满足的条件


06-11日  端午节后的课

自增长 auto_increment
使某个字段的值,自动的增长, 由系统来维护
1. 当添加的字段是null , default ,或不给字段添加值时 , 会自动调用自增长
2. 一般来说是和 primary key 配合使用
3. 单独使用需要配合 unique
4. 自增长也可以是小数,但是非常少用
5. 默认从 1 开始 , 可以通过 alter table 表 auto_increment = # 来指定
6. 插入值时可以直接给auto_increment 指定值, 会从自增长字段最大值再开始自增长

索引
索引的价值在于提高一个海量表的检索速度
索引的算法有 btree  二叉树算法   hash  哈希算法

索引的分类 :
1. 主键索引 (primary key)
2. 唯一索引 (unique)
3. 普通索引 (index)
4. 全文索引 (fulltext)

索引的原理 :
没有索引时查找数据 , 在不做limit 时 , 会查找每一条的数据,直到全部查找完返回结果
添加索引后 , 会形成一个二叉树 , 通过二叉树的算法匹配数据

索引的代价 :
1. 占用磁盘空间
2. 添加,修改,删除数据时 , 速度会有影响 , 但是不大 (通过二叉树节点.找到位置,添加)
3. 只有添加索引的字段才会提高查询速度 , 需要分别给检索字段添加索引
4. 使用索引 , 是用空间换时间(经典)


创建索引 :


--主键索引 :
1. 创建表时 , 给字段名指定主键   id int key,
2. 创建表的最后,指定某字段为主键 id int,name varchar(20),primary key(id)
3. alter table 表 add primary key(id);

主键索引的特点 :
1. 一个表中最多有一个主键索引(可以是复合主键)
2. 主键索引的效率最高
3. 创基主键索引的字段 ,不能为null ,不能重复
4. 数据类型基本上是 int

--唯一索引
1. 创建表时,指定unique
2. 创建表的最后 ,指定某字段为unique
3. alter table 表 add unique(字段)
4. create unique index 索引名 on 表(字段);

唯一索引特点 :
1. 一个表中可以有多个唯一索引
2. 效率很高
3. 添加唯一索引 , 要可以确定值不重复
4. 如果在唯一索引 指定 not null ,可以算等价于一个主键索引

--普通索引
1. 创建表的最后,指定字段为index索引   index(字段)
2. alter table 表 add index(字段)
3. create index 索引名(inx_字段名) on 表(字段);

普通索引的特点 :
1. 一个表中可以有多个普通索引, 在实际开发中使用频繁
2. 要给会有重复值的字段创建索引 , 应使用普通索引

--全文索引 fulltext
当对某些文章字段,或有大量文字的字段进行检索时, 会使用全文索引 , 但是要求表的存储引擎是 myisam
默认全文索引只支持英文和数字 , 要对中文进行全文检索 , 可以使用 mysql 插件 mysqlcft 或使用sphinx 的中文版(coreseek)

创建全文索引 :
1. 创建表的最后指定  fulltest(字段)

使用全文索引 :
不能直接select......字段 like '''' ,无法用到全文索引
可以使用 关键字 explain select .....  查看select 是否用到索引
select  * from 表  where match(字段1,...) against('查询的数据');

全文索引的几个概念 :
--停止词 : 不会对一般意义的单词建索引 (a,aa等)
--匹配度 : mysql的全文索引机制 , 是以匹配度来返回结果


查询索引 :
1. show keys from 表;
2. show index from 表;
3. show indexes from 表;
4. desc 表;
5. show create table 表;


删除索引 :
1. 删除主键 alter table 表 drop primary key
2. alter table 表 drop index 索引名
3. drop index 索引名 on table;
重点是要先查询到索引名

修改索引 :
删除,再创建


创建索引的一般原则
1. 频繁作为查询条件的字段应创建索引
2. 唯一性太差的字段不适合单独创建索引 (sex 等)
3 .更新非常频繁的字段不适合创建索引
4. 不会出现where 子语的字段 不该建索引

创建索引可以大幅的提高检索速度


事务
就是一组dml语句,这些语句存在逻辑上的相关性,这一组dml语句要么全部成功,要么全部失败,是一个整体
事务还规定了不同的客户端看到的数据是不相用的
如票务系统 , 如果不加事务 , 会出现同一张票卖给多人的情况
 
mysql控制台控制事务 :  
1. start transaction ; 开始事务
2. savepoint 保存点名 ;
3. 进行各种操作
4. 如需要回滚到保存点
    rollback to 保存点名

事务(回滚)使用的注意事项 :
1. 没设置保存点 , 可以回滚到开始事务时的状态
2. 可以设置多个保存点
3. 如果一个事务被提交(commit) , 则不可以回滚
4. 表的存储引擎必须是 innodb
5. 开始事务可以时start transaction ,也可以是 set autocommit = 0;


php程序控制事务
<?php
//事务的控制
mysql_query('start transaction');
$res1 = mysql_query($sql1);
$res2 = mysql_query($sql2);

if($res1 && $res2) {
    //两个结果都是真,提交
    mysql_query('commit');
}else{
    //任何一个不成功,回滚
    mysql_query('rollback');
    exit;
}


?>

事务隔离级别 :
当我们的mysql表 , 被多个线程或者客户端并发操作时, mysql 提供一种
机制, 可以让不用的事务在操作数据时 , 具有隔离性

查看错误级别  : select @@tx_isolation;

脏读 : 一个客户端(事务) 会读取到另一个客户端(事务)没有提交的修改数据
不可重复读 :
幻读 :

如何设置事务的隔离级别(具体的隔离级别参看手册)
mysql>set session transction isolation  level 隔离级别

mysql 的默认隔离级别是 repeatable_read 可重复读

四种级别
1. 读未提交 read uncommitted
2. 读已提交 read committed
3. 可重复读 repeatable read
4. 可串行化 serializable


事务的四大特性acid
1. 原子性(atomicity)
2. 一致性(consistency)
3. 隔离性(isolation)
4. 持久性(durability)

表的存储引擎
从事务安全性的角度, 可以把存储引擎分为 BDB 和 INNODB
事务非安全性 : MYISAM MEMORY

MyISAM , 不支持事务, 不支持外键 , 但访问速度快
1. 对事务的完整性没有要求的话, 可以使用
2. 不能真正删掉占用的空间, 会产生碎片, 需要处理
   -> optimize table 表

InnoDB : 支持事务 , 支持外键 , 但是效率稍差

Memory : 所有数据都放在内存里,速度快 . 但是服务关闭, 数据丢失,表结构还在
适合存放频繁变化的小数据     经典使用 : 存放用户的在线状态

如何选择适当的存储引擎 :
1 . 应用不需要事务 ,处理的只是基本 的crud .myisam 是不二选择
2. 需要事务 ,innodb
3. 经典使用  用户的在线状态


视图 :
create viwe 视图名 as select 字段 from 表;
修改了视图 , 对基表数据有影响 , 反之亦然
修改视图
alter view 视图名 as select 更改的字段 from 表;

视图的作用 : 简化sql 语句

create view view1 as select goods_id, cat_id,goods_name,shop_price from ecs_goods
order by cat_id,shop_price desc;

create  view view2 as select  * from view1 group by view1.cat_id;
这里发现一个问题 , 对视图进行分组查询 , 并没有返回上一 个视图分组的第一条记录
原因是 : 默认情况下 , 视图都是从基表中获取数据     解决方法  =>修改视图运算规则(algorithm) 为 temptable

create  algorithm = temptable view view1 as select goods_id, cat_id,goods_name,shop_price from ecs_goods
order by cat_id,shop_price desc;

说明下
1. 创建视图, 不可以包含子查询 , 但可以使用另外的视图
2. 视图创建可以指定期算法  , marge/temptable/undefined
3. temptable : 是对临时表进行查询
   marge : 是对基表进行查询
   默认情况下使用 undefined ,即marge

视图特点 :
1. 视图有利于表的安全性(只显示想显示的字段, 隐藏需要保密的字段)
2. 提高表的性能
3. 灵活


6-12

mysql 用户管理

mysql 用户都放在mysql ->user表中

--创建用户
create user '用户名'@'登陆主机/ip' identified by '密码';
新创建的用户权限默认都是no
注意 : mysql 将    '用户名'@'登陆主机/ip'   看作是一个完整用户名

--删除用户
drop user '用户名'@'登陆主机名';

--修改密码
1. 修改自己的密码
mysql->set password = password('密码');
2. root 用户修改用户密码
mysql-> set password for '用户名'@'登陆主机/ip = password('密码');

--给用户分配权限
grant 权限列表 on 库.对象名(表名,视图名等) to '用户名'@'主机名' [identified by '密码'];
说明 : 如果不给[identified by '密码'] 表时直接给某用户分配权限
     如果给了, 用户存在 ->分配权限时修改密码 , 用户不存在 -> 创建新用户 并分配权限
细节:
1. 分配所有表的所有权限
grant all on *.* to '用户名'@'主机名';
2. 偶尔发生分配权限后没有立即生效的问题:
    ->刷新权限指令   flush privileges ;

--回收权限
revoke 权限 on 库.对象名 from  '用户名'@'主机名';
说明 : 回收所有权限后(revoke all on **) , 如果是当时单独分配的权限 , 并不会被回收
        -> 再单独回收下这个权限

--如何查找用户的权限
show grants for  '用户名'@'主机名';

细节说明 :
1. 创建用户的时候, 如果不指定Host , 则为% , %表示所有ip 都有连接权限
    -> 效果上可以实现远程登录 , 必须禁止.