㈠ java hibernate 原生sql查詢。
//原生sql查詢可以使用createSQLQuery(String sql)方法 下面代碼表示查詢所有的用戶
List<User> users=session.createSQLQuery("select * from user").list();
㈡ 原生sql是什麼意思
原生sql：資料庫能直接執行的sql語句，比如能在oracle，mssql，mysql，db2等資料庫中直接執行
非原生sql：一般指根據指定的程序規則，自動生成的sql，比如最經典的，linq
to
sql
㈢ mybatis動態sql與原生sql哪種好\
MyBatis的動態SQL是基於OGNL表達式的，它可以幫助我們方便的在SQL語句中實現某些邏輯。
MyBatis中用於實現動態SQL的元素主要有：
if
choose（when，otherwise）
trim
where
set
foreach
㈣ SQL查詢和原生SQL查詢有什麼區別
SQL 中，等於就是唯一條件，例如id = 1，那麼就查出id 是 1的數據行。
而in 或者 not in 就是在某個范圍內或者不在某個范圍內。
當一個查詢是另一個查詢的條件時，稱之為子查詢。其實這也就是嵌套查詢。
例如 selete top 10 from student where age > 10
查找年齡大於10歲的孩子的前十個。
where age > 10就是作為子查詢的存在。
你上面問的in 之類的，其實一般也是用於嵌套查詢的。
㈤ thinkphp 原生sql 怎麼寫
TP的模型可以支持原生SQL操作，提供了query和execute兩個方法，為什麼原生SQL還要區分兩個方法呢，原因有兩個：
1、返回類型不同
query用於查詢，返回的是數據集，和select或者findall一樣，所以可以直接在模板裡面使用volist標簽輸出query的查詢結果
execute用於寫操作，返回的是狀態或者影響的記錄數
2、讀寫統計需要
為了便於統計當前的數據讀寫次數，把資料庫的讀和寫操作分開（對應的就是query和execute）
使用原生SQL很簡單，我們甚至不需要實例化任何的模型，例如：
$Model=newModel();//實例化一個空模型
下面的方法是等效的
$Model=D();或者$Model=M();
//下面執行原生SQL操作
$Model->query('select*fromthink_userwherestatus=1');
$Model->execute('updatethink_usersetstatus=1whereid=1');
如果你實例化了某個模型，仍然可以執行原生SQL操作，不受影響，例如：
$User=D('User');
$User->query('select*fromthink_userwherestatus=1');
$User->execute('updatethink_usersetstatus=1whereid=1');
在這種情況下面，我們可以簡化SQL語句的寫法，例如：
$User->query('select*from__TABLE__wherestatus=1');
$User->execute('update__TABLE__setstatus=1whereid=1');
系統會自動把__TABLE__替換成當前模型對應的數據表名稱，實際的數據表由模型決定。
通常來說，我們都是使用原生SQL操作實現一些ORM和CURD比較難實現的操作，另外，如果SQL不復雜的話原生SQL的效率和連貫操作的效率差別是微乎其微的，TP本身的ORM實現也是相當高效的。
更多的 相關教程 可以 到 我要學it網 獲取
㈥ hibernate，jpa資料庫連接問題。我沒法確定要連接什麼資料庫，但是我要用原生sql來update數據
寫個適配器器吧，傳入資料庫類型，輸出拼接的sql。
其實個人更建議你使用hibernate的Hql來作sql相關操作，首先它語法和通用Sql是近似的，不一樣的地方在於 語句里寫的是類名 不是表名，最後hibernate會根據Hql翻譯成當前資料庫可執行的sql來執行，這樣你就不需要去判斷究竟是什麼資料庫，寫法支持不支持。
當然，如果你的語句特復雜一定得用Sql server或者Oracle的特殊語法，那沒辦法，寫個適配器吧
以下是HQL相關資料
HQL查詢：
Criteria查詢對查詢條件進行了面向對象封裝，符合編程人員的思維方式，不過HQL(Hibernate Query Lanaguage)查詢提供了更加豐富的和靈活的查詢特性，因此
Hibernate將HQL查詢方式立為官方推薦的標准查詢方式，HQL查詢在涵蓋Criteria查詢的所有功能的前提下，提供了類似標准SQL語句的查詢方式，同時也提供了更
加面向對象的封裝。完整的HQL語句形勢如下：
Select/update/delete…… from …… where …… group by …… having …… order by …… asc/desc
其中的update/delete為Hibernate3中所新添加的功能，可見HQL查詢非常類似於標准SQL查詢。由於HQL查詢在整個Hibernate實體操作體系中的核心地位，這一節我
將專門圍繞HQL操作的具體技術細節進行講解。
1、 實體查詢：
有關實體查詢技術，其實我們在先前已經有多次涉及，比如下面的例子：
String hql=」from User user 」;
List list=session.CreateQuery(hql).list();
上面的代碼執行結果是，查詢出User實體對象所對應的所有數據，而且將數據封裝成User實體對象，並且放入List中返回。這里需要注意的是，Hibernate的實體查
詢存在著對繼承關系的判定，比如我們前面討論映射實體繼承關系中的Employee實體對象，它有兩個子類分別是HourlyEmployee，SalariedEmployee,如果有這樣的
HQL語句：「from Employee」,當執行檢索時Hibernate會檢索出所有Employee類型實體對象所對應的數據（包括它的子類HourlyEmployee，SalariedEmployee對應
的數據）。
因為HQL語句與標准SQL語句相似，所以我們也可以在HQL語句中使用where字句，並且可以在where字句中使用各種表達式，比較操作符以及使用「and」,」or」連接
不同的查詢條件的組合。看下面的一些簡單的例子：
from User user where user.age=20;
from User user where user.age between 20 and 30;
from User user where user.age in(20,30);
from User user where user.name is null;
from User user where user.name like 『%zx%』;
from User user where (user.age%2)=1;
from User user where user.age=20 and user.name like 『%zx%』;
2、 實體的更新和刪除：
在繼續講解HQL其他更為強大的查詢功能前，我們先來講解以下利用HQL進行實體更新和刪除的技術。這項技術功能是Hibernate3的新加入的功能，在Hibernate2
中是不具備的。比如在Hibernate2中，如果我們想將資料庫中所有18歲的用戶的年齡全部改為20歲，那麼我們要首先將年齡在18歲的用戶檢索出來，然後將他們的
年齡修改為20歲，最後調用Session.update()語句進行更新。在Hibernate3中對這個問題提供了更加靈活和更具效率的解決辦法，如下面的代碼：
Transaction trans=session.beginTransaction();
String hql=」update User user set user.age=20 where user.age=18」;
Query queryupdate=session.createQuery(hql);
int ret=queryupdate.executeUpdate();
trans.commit();
通過這種方式我們可以在Hibernate3中，一次性完成批量數據的更新，對性能的提高是相當的可觀。同樣也可以通過類似的方式來完成delete操作，如下面的代碼
：
Transaction trans=session.beginTransaction();
String hql=」delete from User user where user.age=18」;
Query queryupdate=session.createQuery(hql);
int ret=queryupdate.executeUpdate();
trans.commit();
如果你是逐個章節閱讀的化，那麼你一定會記起我在第二部分中有關批量數據操作的相關論述中，討論過這種操作方式，這種操作方式在Hibernate3中稱為bulk
delete/update，這種方式能夠在很大程度上提高操作的靈活性和運行效率，但是採用這種方式極有可能引起緩存同步上的問題(請參考相關論述)。
3、 屬性查詢：
很多時候我們在檢索數據時，並不需要獲得實體對象所對應的全部數據，而只需要檢索實體對象的部分屬性所對應的數據。這時候就可以利用HQL屬性查詢技術
，如下面程序示例：
List list=session.createQuery(「select user.name from User user 」).list();
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
我們只檢索了User實體的name屬性對應的數據，此時返回的包含結果集的list中每個條目都是String類型的name屬性對應的數據。我們也可以一次檢索多個屬性，
如下面程序：
List list=session.createQuery(「select user.name,user.age from User user 」).list();
for(int i=0;i<list.size();i++){
Object[] obj=(Object[])list.get(i);
System.out.println(obj[0]);
System.out.println(obj[1]);
}
此時返回的結果集list中，所包含的每個條目都是一個Object[]類型，其中包含對應的屬性數據值。作為當今我們這一代深受面向對象思想影響的開發人員，可能
會覺得上面返回Object[]不夠符合面向對象風格，這時我們可以利用HQL提供的動態構造實例的功能對這些平面數據進行封裝，如下面的程序代碼：
List list=session.createQuery(「select new User(user.name,user.age) from User user 」).list();
for(int i=0;i<list.size();i++){
User user=(User)list.get(i);
System.out.println(user.getName());
System.out.println(user.getAge());
}
這里我們通過動態構造實例對象，對返回結果進行了封裝，使我們的程序更加符合面向對象風格，但是這里有一個問題必須注意，那就是這時所返回的User對象，
僅僅只是一個普通的Java對象而以，除了查詢結果值之外，其它的屬性值都為null（包括主鍵值id），也就是說不能通過Session對象對此對象執行持久化的更新操
作。如下面的代碼：
List list=session.createQuery(「select new User(user.name,user.age) from User user 」).list();
for(int i=0;i<list.size();i++){
User user=(User)list.get(i);
user.setName(「gam」);
session.saveOrUpdate(user);//這里將會實際執行一個save操作，而不會執行update操作，因為這個User對象的id屬性為null，Hibernate會把它作為一個自由對
象（請參考持久化對象狀態部分的論述），因此會對它執行save操作。
}
4、 分組與排序
A、Order by子句：
與SQL語句相似，HQL查詢也可以通過order by子句對查詢結果集進行排序，並且可以通過asc或者desc關鍵字指定排序方式，如下面的代碼：
from User user order by user.name asc,user.age desc;
上面HQL查詢語句，會以name屬性進行升序排序，以age屬性進行降序排序，而且與SQL語句一樣，默認的排序方式為asc,即升序排序。
B、Group by子句與統計查詢：
在HQL語句中同樣支持使用group by子句分組查詢，還支持group by子句結合聚集函數的分組統計查詢，大部分標準的SQL聚集函數都可以在HQL語句中使用，比如：
count(),sum(),max(),min(),avg()等。如下面的程序代碼：
String hql=」select count(user),user.age from User user group by user.age having count(user)>10 」;
List list=session.createQuery(hql).list();
C、優化統計查詢：
假設我們現在有兩張資料庫表，分別是customer表和order表，它們的結構如下：
customer
ID varchar2(14)
age number(10)
name varchar2(20)
order
ID varchar2(14)
order_number number(10)
customer_ID varchar2(14)
現在有兩條HQL查詢語句，分別如下：
from Customer c inner join c.orders o group by c.age;(1)
select c.ID,c.name,c.age,o.ID,o.order_number,o.customer_ID
from Customer c inner join c.orders c group by c.age;(2)
這兩條語句使用了HQL語句的內連接查詢（我們將在HQL語句的連接查詢部分專門討論），現在我們可以看出這兩條查詢語句最後所返回的結果是一樣的，但是它們
其實是有明顯區別的，語句（1）檢索的結果會返回Customer與Order持久化對象，而且它們會被置於Hibernate的Session緩存之中，並且Session會負責它們在緩存
中的唯一性以及與後台資料庫數據的同步，只有事務提交後它們才會從緩存中被清除；而語句（2）返回的是關系數據而並非是持久化對象，因此它們不會佔用
Hibernate的Session緩存，只要在檢索之後應用程序不在訪問它們，它們所佔用的內存就有可能被JVM的垃圾回收器回收，而且Hibernate不會同步對它們的修改。
在我們的系統開發中，尤其是Mis系統，不可避免的要進行統計查詢的開發，這類功能有兩個特點：第一數據量大；第二一般情況下都是只讀操作而不會涉及到對統
計數據進行修改，那麼如果採用第一種查詢方式，必然會導致大量持久化對象位於Hibernate的Session緩存中，而且Hibernate的Session緩存還要負責它們與數據
庫數據的同步。而如果採用第二種查詢方式，顯然就會提高查詢性能，因為不需要Hibernate的Session緩存的管理開銷，而且只要應用程序不在使用這些數據，它
們所佔用的內存空間就會被回收釋放。
因此在開發統計查詢系統時，盡量使用通過select語句寫出需要查詢的屬性的方式來返回關系數據，而避免使用第一種查詢方式返回持久化對象（這種方式是在有
修改需求時使用比較適合），這樣可以提高運行效率並且減少內存消耗。㊣真正的高手並不是精通一切，而是精通在合適的場合使用合適的手段。
5、 參數綁定：
Hibernate中對動態查詢參數綁定提供了豐富的支持，那麼什麼是查詢參數動態綁定呢？其實如果我們熟悉傳統JDBC編程的話，我們就不難理解查詢參數動態綁定，
如下代碼傳統JDBC的參數綁定：
PrepareStatement pre=connection.prepare(「select * from User where user.name=?」);
pre.setString(1,」zhaoxin」);
ResultSet rs=pre.executeQuery();
在Hibernate中也提供了類似這種的查詢參數綁定功能，而且在Hibernate中對這個功能還提供了比傳統JDBC操作豐富的多的特性，在Hibernate中共存在4種參數綁
定的方式，下面我們將分別介紹：
A、 按參數名稱綁定：
在HQL語句中定義命名參數要用」:」開頭，形式如下：
Query query=session.createQuery(「from User user where user.name=:customername and user.customerage=:age 」);
query.setString(「customername」,name);
query.setInteger(「customerage」,age);
上面代碼中用:customername和:customerage分別定義了命名參數customername和customerage，然後用Query介面的setXXX()方法設定名參數值，setXXX()方法包
含兩個參數，分別是命名參數名稱和命名參數實際值。
B、 按參數位置邦定：
在HQL查詢語句中用」?」來定義參數位置，形式如下：
Query query=session.createQuery(「from User user where user.name=? and user.age =? 」);
query.setString(0,name);
query.setInteger(1,age);
同樣使用setXXX()方法設定綁定參數，只不過這時setXXX()方法的第一個參數代表邦定參數在HQL語句中出現的位置編號（由0開始編號），第二個參數仍然代表參
數實際值。
註：在實際開發中，提倡使用按名稱邦定命名參數，因為這不但可以提供非常好的程序可讀性，而且也提高了程序的易維護性，因為當查詢參數的位置發生改變時
，按名稱邦定名參數的方式中是不需要調整程序代碼的。
C、 setParameter()方法：
在Hibernate的HQL查詢中可以通過setParameter()方法邦定任意類型的參數，如下代碼：
String hql=」from User user where user.name=:customername 」;
Query query=session.createQuery(hql);
query.setParameter(「customername」,name,Hibernate.STRING);
如上面代碼所示，setParameter()方法包含三個參數，分別是命名參數名稱，命名參數實際值，以及命名參數映射類型。對於某些參數類型setParameter()方法可
以更具參數值的Java類型，猜測出對應的映射類型，因此這時不需要顯示寫出映射類型，像上面的例子，可以直接這樣寫：
query.setParameter(「customername」,name);但是對於一些類型就必須寫明映射類型，比如java.util.Date類型，因為它會對應Hibernate的多種映射類型，比如
Hibernate.DATA或者Hibernate.TIMESTAMP。
D、 setProperties()方法：
在Hibernate中可以使用setProperties()方法，將命名參數與一個對象的屬性值綁定在一起，如下程序代碼：
Customer customer=new Customer();
customer.setName(「pansl」);
customer.setAge(80);
Query query=session.createQuery(「from Customer c where c.name=:name and c.age=:age 」);
query.setProperties(customer);
setProperties()方法會自動將customer對象實例的屬性值匹配到命名參數上，但是要求命名參數名稱必須要與實體對象相應的屬性同名。
這里還有一個特殊的setEntity()方法，它會把命名參數與一個持久化對象相關聯，如下面代碼所示：
Customer customer=(Customer)session.load(Customer.class,」1」);
Query query=session.createQuery(「from Order order where order.customer=:customer 」);
query. setProperties(「customer」,customer);
List list=query.list();
上面的代碼會生成類似如下的SQL語句：
Select * from order where customer_ID=』1』;
E、 使用綁定參數的優勢：
我們為什麼要使用綁定命名參數？任何一個事物的存在都是有其價值的，具體到綁定參數對於HQL查詢來說，主要有以下兩個主要優勢：
①、 可以利用資料庫實施性能優化，因為對Hibernate來說在底層使用的是PrepareStatement來完成查詢，因此對於語法相同參數不同的SQL語句，可
以充分利用預編譯SQL語句緩存，從而提升查詢效率。
②、 可以防止SQL Injection安全漏洞的產生：
SQL Injection是一種專門針對SQL語句拼裝的攻擊方式，比如對於我們常見的用戶登錄，在登錄界面上，用戶輸入用戶名和口令，這時登錄驗證程序可能會生成如
下的HQL語句：
「from User user where user.name=』」+name+」』 and user.password=』」+password+」』 」
這個HQL語句從邏輯上來說是沒有任何問題的，這個登錄驗證功能在一般情況下也是會正確完成的，但是如果在登錄時在用戶名中輸入」zhaoxin or 『x』=』x」,
這時如果使用簡單的HQL語句的字元串拼裝，就會生成如下的HQL語句：
「from User user where user.name=』zhaoxin』 or 『x』=』x』 and user.password=』admin』 」;
顯然這條HQL語句的where字句將會永遠為真，而使用戶口令的作用失去意義，這就是SQL Injection攻擊的基本原理。
而使用綁定參數方式，就可以妥善處理這問題,當使用綁定參數時，會得到下面的HQL語句：
from User user where user.name=』』zhaoxin』』 or 『』x=』』x』』 『 and user.password=』admin』;由此可見使用綁定參數會將用戶名中輸入的單引號解
析成字元串（如果想在字元串中包含單引號，應使用重復單引號形式），所以參數綁定能夠有效防止SQL Injection安全漏洞。
㈦ 淺談hql和sql的區別，描述特別需要注意的地方
1.hql與sql的區別
sql 面向資料庫表查詢
hql 面向對象查詢
hql ： from 後面跟的 類名＋類對象 where 後 用 對象的屬性做條件
sql： from 後面跟的是表名 where 後 用表中欄位做條件
查詢
在Hibernate中使用查詢時，一般使用Hql查詢語句。
HQL（Hibernate Query Language），即Hibernate的查詢語言跟SQL非常相像。不過HQL與SQL的最根本的區別，就是它是面向對象的。
使用HQL時需要注意以下幾點：
l 大小寫敏感
因為HQL是面向對象的，而對象類的名稱和屬性都是大小寫敏感的，所以HQL是大小寫敏感的。
Eg.
HQL語句：from Cat as cat where cat.id > 1;與from Cat as cat where cat.ID > 1;是不一樣的，這點與SQL不同。
l from子句
Eg. from Cat，該句返回Cat對象實例，開發人員也可以給其加上別名，eg. from Cat as cat，對於多表查詢的情況，可參考如下：
from Cat as cat, Dog as dog
其它方面都與SQL類似，在此不再贅述。
接下來講一個在Hibernate中查詢的例子。
1.1簡單查詢
List list = session.createQuery("from User as user order by user.loginName").list();
1.2帶單個參數的查詢
List list = session.find("from User as user where user.loginName=?",
loginName,
Hibernate.STRING);
1.3多個參數的查詢
Eg1. 此例採用「?」佔位符的方式
String hql = "from User as user where user.loginName=? and user.orgId=? ";
Query query = session.createQuery(hql);
query.setParameter(1, 'amigo');
query.setParameter(2, new Long(1)) ;
List list = query .list();
Eg2. 此例採用「:paramName」的方式
String hql = "from User as user where user.loginName=:loginName and user.orgId=:orgId ";
Query query = session.createQuery(hql);
query.setParameter('loginName', 'amigo');
query.setParameter('orgId', new Long(1)) ;
List list = query .list();
1.4查詢數量
int count = (Integer) session.createQuery("select count(*) from User").uniqueResult().intValue();
1.5限制查詢起始值和數量的查詢
這種一般是在記錄需要分頁的時候需要用到，例如，在如下的代碼中，限制查詢的開始記錄的位置為50，最大查詢條數為50。
String hql = "from User as user order by user.loginName";
int firstResult= 50;
int maxResults = 50;
Query query = session.createQuery(hql);
query = query.setFirstResult(firstResult);
query.setMaxResults(maxResults);
1.6子查詢
在某些情況下，也需要用到子查詢，例如在下面的例子中，User為用戶對象，UserRole為用戶與角色關聯對象。如下HQL語句將沒有分配角色的用戶對象查找出來。
String hql = "from User user where user.loginName"
+ " not in(select ur.user.loginName from UserRole ur) ";
List list = (session.createQuery(hql)).list();
1.7原生SQL查詢
對於某些復雜的查詢語句，需要調用某種特定的資料庫的特定函數才能解決，Hibernate雖然不推薦使用原生SQL語句來查詢，因為這將破壞資料庫的易移植性，但是Hibernate中也提供了使用原生SQL進行查詢的方法，只需要獲得連接即可。
Eg. 在下面的例子中，用到了Sql Server資料庫中的原生sql語句，如下所示：
String timeUnit = "13";
String sql = "select count(*) count, CONVERT(VARCHAR(" + timeUnit +"), log.gen_datetime,121) timeUnit " + "from Log log";
SQLQuery query = session.createSQLQuery(sql)
.addScalar("count", Hibernate.INTEGER)
.addScalar("timeUnit", Hibernate.STRING);
List list = query.list();
2 新增
在資料庫中新增記錄在Hibernate中不需要使用insert命令，只需要構造新增的對象後，調用Session對象的save(…)方法即可。
2.1新增單個對象
新增單個對象的實例如下，該實例將在用戶表中新增一條記錄。
Session session = HibernateSessionFactory.getSession();
Transaction ts = null;
try {
ts = session.beginTransaction();
User user = new User();
user.setLoginName("amigo");
user.setFullName("阿蜜果");
……
session.save(user) ;
ts.commit();
} catch (Exception e) {
if (ts != null) {
ts.rollback();
}
} finally {
HibernateSessionFactory.closeSession();
}
2.2批量新增對象
對於批量新增對象的情況，需要在新增一部分對象後flush和clear一次，例如，沒批量新增20個對象時手動的flush一次，假設在list為一個用戶列表，裡麵包含很多User對象，那麼要將實現這些對象的批量新增，可採用如下方法：
Session session = HibernateSessionFactory.getSession();
Transaction ts = null;
try {
ts = session.beginTransaction();
for (int i = 0; i < list.size(); i++) {
User user = (User) list.get(i);
session.save(user) ;
if (i % 20 == 0) {
session.flush();
session.clear();
}
}
ts.commit();
} catch (Exception e) {
if (ts != null) {
ts.rollback();
}
} finally {
HibernateSessionFactory.closeSession();
}
3 更新
在hibernate中，更新對象前不需要使用查詢語句：update…，一般需要在取得需要更新的持久化對象後，執行Session對象的update(…)方法。例如：
Session session = HibernateSessionFactory.getSession();
Transaction ts = null;
try {
ts = session.beginTransaction();
//取得持久化對象
User user = session.get(User.class, "amigo");
//對需要修改的屬性進行修改
user.setFullName("阿蜜果");
……
session.update(user) ;
ts.commit();
} catch (Exception e) {
if (ts != null) {
ts.rollback();
}
} finally {
HibernateSessionFactory.closeSession();
}
4 刪除
4.1刪除單個對象
一般在取得某對象後，開發人員可以調用Session對象的delete(…)方法刪除該對象。
Eg. 下面的實例中取得loginName（主鍵）為「amigo」的User對象後，將它刪除。
Session session = HibernateSessionFactory.getSession();
Transaction ts = null;
try {
ts = session.beginTransaction();
//取得持久化對象
User user = session.get(User.class, "amigo");
session.delete(user) ;
ts.commit();
} catch (Exception e) {
if (ts != null) {
ts.rollback();
}
} finally {
HibernateSessionFactory.closeSession();
}
4.2批量刪除對象
對於批量刪除對象的情況，開發人員可以在取得待刪除的對象列表後，一個一個的將對象刪除，對於每個對象的刪除方法，見3.4.1小節。開發人員還可以hql語句來做批量刪除。
Eg. 該實例通過delete語句來刪除記錄，除了loginName為「amigo」的對象為，其餘都刪除，代碼如下所示：
Session session = HibernateSessionFactory.getSession();
Transaction ts = null;
try {
ts = session.beginTransaction();
String hql = "delete User as user where user.loginName != 'amigo'";
Query query = session.createQuery(hql);
int count = query.executeUpdate();
ts.commit();
System.out.println("delete count : " + count); //刪除條數
} catch (Exception e) {
if (ts != null) {
ts.rollback();
}
} finally {
HibernateSessionFactory.closeSession();
}
㈧ python sqlalchemy 怎麼用原生sql語句
接著就從安裝開始介紹吧，以 Debian/Ubuntu 為例（請確保有管理員許可權）：
1.MySQL
復制代碼代碼如下:
apt-get install mysql-server
apt-get install mysql-client
apt-get install libmysqlclient15-dev
2.python-mysqldb
復制代碼代碼如下:
apt-get install python-mysqldb
3.easy_install
復制代碼代碼如下:
wget eak.telecommunity.com/dist/ez_setup.py
python ez_setup.py
4.MySQL-Python
復制代碼代碼如下:
easy_install MySQL-P
㈨ mybatis 原生sql
Hibernate是全自動數據持久化框架，ibatis是半自動，其中sql由開發人獨立完成。
後期因為ibatis的接管人變了，如今升級到mybatis，mybatis有一個比較好的地方，尤其當今面向介面開發比較多，spring也比較火，mybatis在和spring集成的時候，是不用寫數據持久層實現類的，只寫介面就可以映射到xml文件。
㈩ 原生SQL語句和封裝的DB類哪個好用
如果框架的資料庫服務僅僅是「簡化一些常見的資料庫操作」，那麼使用原生 SQL 就無所謂。因為用框架也好，用原生 SQL 也好，查詢出來的結果都只是數組。
如果框架提供了全面 ORM 功能，那麼直接使用原生 SQL 就需要仔細考量一下。因為原生 SQL 查詢出來的結果不是對象，所以無法利用封裝在數據之上的業務方法。