Python中使用SQLAlchemy連線Mysql資料庫（單表操作）
一，SQLAlchemy的安裝
使用
$ easy_install sqlalchemy
或
$ pip install sqlalchemy如果出現什麼錯，就進去root使用者下進行安裝試試，或者網上查查
>>> import sqlalchemy
>>> 這樣說明成功了，切記是小寫哦
二，使用
理論我也不懂，自己查查資料，現在用一個小的案例說一下使用步驟
1，在進行資料操作之前要先連上資料庫。
>>> from sqlalchemy import create_engine
>>> from 是從sqlalchemy中插入必須的模板，DB_CONNECT 是構造資料庫的路徑 ，mysql+mysqldb是說明使用MySQL-Python 來連線，root是資料庫使用者名稱，102是密碼，localhost表示是資料庫在本機上，mydb是要連線的資料庫名字，設定字符集的charset可以省了
create_engine() 會返回一個數據庫引擎，echo 引數為 True 時，會顯示每條執行的 SQL 語句，生產環境下可關閉。
sessionmaker(bind=engine)會生成一個數據庫會話類。這個類的例項可以當成一個數據庫連線，它同時還記錄了一些查詢的資料，並決定什麼時候執行 SQL 語句。由於 SQLAlchemy 自己維護了一個數據庫連線池（預設 5 個連線），也可以自己設定。
得到session 後，就可以執行 SQL 了：
2，在進行操作前先把表給建立了，由於SQLAlchemy 可以和變進行建立連線並且可以通過語言進行見表
mysql> show tables;
Empty set (0.00 sec)
mysql> 此時是沒有表的，現在我們建立一個學生便stu，一個課程表cla和一個成績表grade
>>> from sqlalchemy import Column
>>> from sqlalchemy.types import CHAR, Integer, String
>>> from sqlalchemy.ext.declarative import declarative_base
>>> from random import randint
>>> from sqlalchemy import ForeignKey
>>> BaseModel = declarative_base()
>>> def init_db():
... declarative_base() 建立了一個 BaseModel 類，這個類的子類可以自動與一個表關聯。以 Stu 類為例，它的 tablename 屬性就是資料庫中該表的名稱，它有 id 和 name 這兩個欄位，分別為整型和 30 個定長字元。Column 還有一些其他的引數，我就不解釋了。
最後，BaseModel.metadata.create_all(engine) 會找到 BaseModel 的所有子類，並在資料庫中建立這些表；drop_all() 則是刪除這些表。
現在執行init_db()進行建立表，對應語句如下
>>> init_db()
CREATE TABLE stu (
id INTEGER NOT NULL AUTO_INCREMENT,
name CHAR(30),
PRIMARY KEY (id)
)
CREATE TABLE cla (
id INTEGER NOT NULL AUTO_INCREMENT,
cname CHAR(30),
PRIMARY KEY (id)
)
CREATE TABLE grade (
id INTEGER NOT NULL AUTO_INCREMENT,
uid INTEGER,
cid INTEGER,
gre INTEGER,
PRIMARY KEY (id),
FOREIGN KEY(uid) REFERENCES stu (id),
FOREIGN KEY(cid) REFERENCES cla (id)
)
COMMIT
>>> 以上就是執行時對應的建表語句，現在去資料庫看看錶是否存在，並檢視一個表結構
mysql> show tables;
+----------------+
| Tables_in_mydb |
+----------------+
| cla |
| grade |
| stu |
+----------------+
3 rows in set (0.00 sec)
表已經建立成功了，現在看一下表結構
mysql> desc grade;
+-------+---------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| uid | int(11) | YES | MUL | NULL | |
| cid | int(11) | YES | MUL | NULL | |
| gre | int(11) | YES | | NULL | |
+-------+---------+------+-----+---------+----------------+
4 rows in set (0.00 sec)可以看出 使用SQLAlchemy中的語句和使用SQL語句的結果一樣。接下來就可以插入資料了
>>> stu = Stu(name='a')
>>> session.add(stu)
>>> stu = Stu(name='b')
>>> session.add(stu)
>>> stu = Stu(name='c')
>>> session.add(stu)
>>> stu = Stu(name='d')
>>> session.add(stu)
>>> stu = Stu(name='e')
>>> session.add(stu)
>>>
手動插入了五條記錄，但此時還沒有提交，沒有真正的寫入資料庫
或者使用非ORM方式進行插入
>>>session.execute(Stu.__table__.insert(),[{'name':randint(1,100)} for i in xrange(10000)])
>>>session.commit()
#可以速度更快的插入更多的資料>>> session.commit()
2016-05-09 18:22:16,839 INFO sqlalchemy.engine.base.Engine BEGIN (implicit)
2016-05-09 18:22:16,840 INFO sqlalchemy.engine.base.Engine INSERT INTO stu (name) VALUES (%s)
2016-05-09 18:22:16,840 INFO sqlalchemy.engine.base.Engine ('a',)
2016-05-09 18:22:16,841 INFO sqlalchemy.engine.base.Engine INSERT INTO stu (name) VALUES (%s)
2016-05-09 18:22:16,841 INFO sqlalchemy.engine.base.Engine ('b',)
2016-05-09 18:22:16,841 INFO sqlalchemy.engine.base.Engine INSERT INTO stu (name) VALUES (%s)
2016-05-09 18:22:16,841 INFO sqlalchemy.engine.base.Engine ('c',)
2016-05-09 18:22:16,842 INFO sqlalchemy.engine.base.Engine INSERT INTO stu (name) VALUES (%s)
2016-05-09 18:22:16,842 INFO sqlalchemy.engine.base.Engine ('d',)
2016-05-09 18:22:16,842 INFO sqlalchemy.engine.base.Engine INSERT INTO stu (name) VALUES (%s)
2016-05-09 18:22:16,842 INFO sqlalchemy.engine.base.Engine ('e',)
2016-05-09 18:22:16,843 INFO sqlalchemy.engine.base.Engine COMMIT
>>> 此時真的寫入資料庫了哦。向課程表插入五條
>>> cla = Cla(cname='yuwen')
>>> session.add(cla)
>>> cla = Cla(cname='shuxue')
>>> session.add(cla)
>>> cla = Cla(cname='yingyu')
>>> session.add(cla)
>>> cla = Cla(cname='wuli')
>>> session.add(cla)
>>> cla = Cla(cname='huaxue')
>>> session.add(cla)
>>> session.commit()3,現在開始操作資料
>>> query = session.query(Stu)
>>> for st in query:
... print st.name
...
對應的SQL語句
SELECT stu.id AS stu_id, stu.name AS stu_name
FROM stu
2016-05-09 18:56:07,084 INFO sqlalchemy.engine.base.Engine ()
a
b
c
d
e
>>> print query.all()# # 返回的是一個類似列表的物件
SELECT stu.id AS stu_id, stu.name AS stu_name
FROM stu
2016-05-09 18:58:16,085 INFO sqlalchemy.engine.base.Engine ()
[<__main__.Stu object at 0xb66b3f4c>, <__main__.Stu object at 0xb5e4202c>, <__main__.Stu object at 0xb66b3f8c>, <__main__.Stu object at 0xb5e4206c>, <__main__.Stu object at 0xb6688c0c>]
>>> print query.first().name# 有資料時返回第一條記錄，沒有資料時會返回 None
SELECT stu.id AS stu_id, stu.name AS stu_name
FROM stu
LIMIT %s
2016-05-09 18:59:43,149 INFO sqlalchemy.engine.base.Engine (1,)
a
# print query.one().name# 不存在，或有多行記錄時會丟擲異常
>>> print query.filter(Stu.id == 2).first().name
SELECT stu.id AS stu_id, stu.name AS stu_name
FROM stu
WHERE stu.id = %s
LIMIT %s
2016-05-09 19:04:54,363 INFO sqlalchemy.engine.base.Engine (2, 1)
b
>>> print query.filter('id = 2').first().name # 支援字串
SELECT stu.id AS stu_id, stu.name AS stu_name
FROM stu
WHERE id = 2
LIMIT %s
2016-05-09 19:07:02,016 INFO sqlalchemy.engine.base.Engine (1,)
b
>>> print query.get(2).name # 以主鍵獲取，等效於上句
2016-05-09 19:07:40,007 INFO sqlalchemy.engine.base.Engine SELECT stu.id AS stu_id, stu.name AS stu_name
FROM stu
WHERE stu.id = %s
2016-05-09 19:07:40,007 INFO sqlalchemy.engine.base.Engine (2,)
b
>>> print query.get(2).id
SELECT stu.id AS stu_id, stu.name AS stu_name
FROM stu
WHERE stu.id = %s
2016-05-09 19:08:46,009 INFO sqlalchemy.engine.base.Engine (2,)
2>>> quer2 = session.query(Stu.name)
>>> print quer2.all()
SELECT stu.name AS stu_name
FROM stu
2016-05-09 19:09:46,259 INFO sqlalchemy.engine.base.Engine ()
[('a',), ('b',), ('c',), ('d',), ('e',)]>>> print quer2.limit(1).all() #只返回一條
2016-05-09 19:11:23,383 INFO sqlalchemy.engine.base.Engine SELECT stu.name AS stu_name
FROM stu
LIMIT %s
2016-05-09 19:11:23,383 INFO sqlalchemy.engine.base.Engine (1,)
[('a',)]
>>> print quer2.limit(2).all()#只返回兩條
SELECT stu.name AS stu_name
FROM stu
LIMIT %s
2016-05-09 19:11:29,480 INFO sqlalchemy.engine.base.Engine (2,)
[('a',), ('b',)]>>> print quer2.offset(1).all() #跳過一條，從第二條資料開始查詢
SELECT stu.name AS stu_name
FROM stu
LIMIT %s, 18446744073709551615
2016-05-09 19:13:25,734 INFO sqlalchemy.engine.base.Engine (1,)
[('b',), ('c',), ('d',), ('e',)]
>>> print quer2.offset(3).all() #從第四條資料開始
SELECT stu.name AS stu_name
FROM stu
LIMIT %s, 18446744073709551615
2016-05-09 19:13:39,629 INFO sqlalchemy.engine.base.Engine (3,)
[('d',), ('e',)]#按name降序排序
>>> print quer2.order_by(Stu.name.desc()).all()
SELECT stu.name AS stu_name
FROM stu ORDER BY stu.name DESC
2016-05-09 19:16:56,022 INFO sqlalchemy.engine.base.Engine ()
[('e',), ('d',), ('c',), ('b',), ('a',)]
>>> print quer2.order_by('name desc').all()
SELECT stu.name AS stu_name
FROM stu ORDER BY name desc
2016-05-09 19:17:09,851 INFO sqlalchemy.engine.base.Engine ()
[('e',), ('d',), ('c',), ('b',), ('a',)]
#按name降序，有重複的按id升序排序
>>> print session.query(Stu.id).order_by('name desc','id').all()
SELECT stu.id AS stu_id
FROM stu ORDER BY name desc, stu.id
2016-05-09 19:20:34,818 INFO sqlalchemy.engine.base.Engine ()
[(5L,), (4L,), (3L,), (2L,), (1L,)]#scalar()在有多條資料時使用報出異常,all()可以使用多條也可以使用一條
#>>> print quer2.filter(Stu.id>2).scalar()
>>> print quer2.filter(Stu.id>2).all()
SELECT stu.name AS stu_name
FROM stu
WHERE stu.id > %s
2016-05-09 19:56:47,760 INFO sqlalchemy.engine.base.Engine (2,)
[('c',), ('d',), ('e',)]
>>> print quer2.filter(Stu.id==2).all()
SELECT stu.name AS stu_name
FROM stu
WHERE stu.id = %s
2016-05-09 19:57:47,901 INFO sqlalchemy.engine.base.Engine (2,)
[('b',)]
>>> print quer2.filter(Stu.id==2).scalar()
SELECT stu.name AS stu_name
FROM stu
WHERE stu.id = %s
2016-05-09 19:23:38,761 INFO sqlalchemy.engine.base.Engine (2,)
b
>>> print quer2.filter('id=2').scalar()
SELECT stu.name AS stu_name
FROM stu
WHERE id=2
2016-05-09 19:43:47,797 INFO sqlalchemy.engine.base.Engine ()
b
#在此中‘，’等價於and
>>> print query2.filter(Stu.id>1,Stu.name !='a').first()
SELECT stu.name AS stu_name
FROM stu
WHERE stu.id > %s AND stu.name != %s
LIMIT %s
2016-05-09 19:51:14,571 INFO sqlalchemy.engine.base.Engine (1, 'a', 1)
('b',)
>>>
#此種迭代也類似與and
>>> query3 = query2.filter(Stu.id>1)
>>> query3 = query3.filter(Stu.name != 'a')
>>> query3.first()
2016-05-09 19:53:50,150 INFO sqlalchemy.engine.base.Engine SELECT stu.name AS stu_name
FROM stu
WHERE stu.id > %s AND stu.name != %s
LIMIT %s
2016-05-09 19:53:50,151 INFO sqlalchemy.engine.base.Engine (1, 'a', 1)
('b',)
#or_就是類似or
>>> print query2.filter(or_(Stu.id == 1,Stu.id==2)).all()
2016-05-09 19:55:59,383 INFO sqlalchemy.engine.base.Engine SELECT stu.name AS stu_name
FROM stu
WHERE stu.id = %s OR stu.id = %s
2016-05-09 19:55:59,383 INFO sqlalchemy.engine.base.Engine (1, 2)
[('a',), ('b',)]
# in的用法
>>> print query2.filter(Stu.id.in_((1,2,3))).all()
SELECT stu.name AS stu_name
FROM stu
WHERE stu.id IN (%s, %s, %s)
2016-05-09 20:01:01,729 INFO sqlalchemy.engine.base.Engine (1, 2, 3)
[('a',), ('b',), ('c',)]
>>>
#為null的一些用法
>>> query4 = session.query(Stu.id)
>>> print query4.filter(Stu.name==None).scalar()
SELECT stu.id AS stu_id
FROM stu
WHERE stu.name IS NULL
2016-05-09 20:02:59,821 INFO sqlalchemy.engine.base.Engine ()
None
>>>
>>> print query4.filter('name is null').scalar()
SELECT stu.id AS stu_id
FROM stu
WHERE name is null
2016-05-09 20:03:40,312 INFO sqlalchemy.engine.base.Engine ()
None
>>>
#不為null的一些用法
>>> print query4.filter(not_(Stu.name == None)).all()
SELECT stu.id AS stu_id
FROM stu
WHERE stu.name IS NOT NULL
2016-05-09 20:04:49,888 INFO sqlalchemy.engine.base.Engine ()
[(1L,), (2L,), (3L,), (4L,), (5L,)]
>>>
>>> print query4.filter(Stu.name != None).all()
SELECT stu.id AS stu_id
FROM stu
WHERE stu.name IS NOT NULL
2016-05-09 20:05:42,724 INFO sqlalchemy.engine.base.Engine ()
[(1L,), (2L,), (3L,), (4L,), (5L,)]
>>> #func條用各種函式的用法
>>> print query4.count()
SELECT count(*) AS count_1
FROM (SELECT stu.id AS stu_id
FROM stu) AS anon_1
2016-05-09 20:08:43,352 INFO sqlalchemy.engine.base.Engine ()
5
>>> print session.query(func.count('*')).select_from(Stu).scalar()
SELECT count(%s) AS count_1
FROM stu
2016-05-09 20:08:43,356 INFO sqlalchemy.engine.base.Engine ('*',)
5
>>> print session.query(func.count('1')).select_from(Stu).scalar()
SELECT count(%s) AS count_1
FROM stu
2016-05-09 20:08:43,362 INFO sqlalchemy.engine.base.Engine ('1',)
5
>>> print session.query(func.count(Stu.id)).scalar()
SELECT count(stu.id) AS count_1
FROM stu
2016-05-09 20:08:43,369 INFO sqlalchemy.engine.base.Engine ()
5
>>> print session.query(func.count('*')).filter(Stu.id > 0).scalar() # filter()中包含Stu，因此不需要指定表
SELECT count(%s) AS count_1
FROM stu
WHERE stu.id > %s
2016-05-09 20:08:43,377 INFO sqlalchemy.engine.base.Engine ('*', 0)
5
>>> print session.query(func.count('*')).filter(Stu.name == 'a').limit(1).scal() == 1 # 可以用 limit() 限制 count() 的返回數
SELECT count(%s) AS count_1
FROM stu
WHERE stu.name = %s
LIMIT %s
2016-05-09 20:08:43,394 INFO sqlalchemy.engine.base.Engine ('*', 'a', 1)
True
>>> print session.query(func.sum(Stu.id)).scalar()
SELECT sum(stu.id) AS sum_1
FROM stu
2016-05-09 20:08:43,401 INFO sqlalchemy.engine.base.Engine ()
15
>>> print session.query(func.now()).scalar() # func 後可以跟任意函式名，只要該據庫支援
SELECT now() AS now_1
2016-05-09 20:08:43,406 INFO sqlalchemy.engine.base.Engine ()
2016-05-09 20:08:43
>>> print session.query(func.current_timestamp()).scalar()
SELECT CURRENT_TIMESTAMP AS current_timestamp_1
2016-05-09 20:08:43,411 INFO sqlalchemy.engine.base.Engine ()
2016-05-09 20:08:43
>>> print session.query(func.md5(Stu.name)).filter(Stu.id == 1).scalar()
SELECT md5(stu.name) AS md5_1
FROM stu
WHERE stu.id = %s
2016-05-09 20:08:44,841 INFO sqlalchemy.engine.base.Engine (1,)
0cc175b9c0f1b6a831c399e269772661
>>>
#修改資料
>>> query.filter(Stu.id==1).update({Stu.name:'li'})
UPDATE stu SET name=%s WHERE stu.id = %s
2016-05-09 20:12:57,027 INFO sqlalchemy.engine.base.Engine ('li', 1)
1L
#刪除資料
>>> query = session.query(Grade)
>>> query.filter(Grade.id == 1).delete()
DELETE FROM grade WHERE grade.id = %s
2016-05-09 20:28:18,638 INFO sqlalchemy.engine.base.Engine (1,)
1L
>>>
此時沒有提交，在資料庫中環視存在的
mysql> select * from grade;
+----+------+------+------+
| id | uid | cid | gre |
+----+------+------+------+
| 1 | 1 | 1 | 60 |
| 2 | 2 | 1 | 66 |
| 3 | 5 | 1 | 66 |
| 4 | 5 | 5 | 96 |
| 5 | 5 | 3 | 96 |
| 6 | 3 | 2 | 96 |
| 7 | 3 | 4 | 76 |
| 8 | 4 | 4 | 76 |
| 9 | 4 | 3 | 76 |
| 10 | 4 | 5 | 76 |
| 11 | 1 | 4 | 76 |
| 12 | 1 | 5 | 76 |
| 13 | 2 | 5 | 76 |
| 14 | 3 | 3 | 60 |
| 15 | 2 | 3 | 50 |
+----+------+------+------+
15 rows in set (0.00 sec)
#開始提交
>>> session.commit()
2016-05-09 20:31:02,461 INFO sqlalchemy.engine.base.Engine COMMIT
>>>
mysql> select * from grade;
+----+------+------+------+
| id | uid | cid | gre |
+----+------+------+------+
| 2 | 2 | 1 | 66 |
| 3 | 5 | 1 | 66 |
| 4 | 5 | 5 | 96 |
| 5 | 5 | 3 | 96 |
| 6 | 3 | 2 | 96 |
| 7 | 3 | 4 | 76 |
| 8 | 4 | 4 | 76 |
| 9 | 4 | 3 | 76 |
| 10 | 4 | 5 | 76 |
| 11 | 1 | 4 | 76 |
| 12 | 1 | 5 | 76 |
| 13 | 2 | 5 | 76 |
| 14 | 3 | 3 | 60 |
| 15 | 2 | 3 | 50 |
+----+------+------+------+
14 rows in set (0.00 sec)
也獲取不到物件了
>>> print query.get(1)
SELECT grade.id AS grade_id, grade.uid AS grade_uid, grade.cid AS grade_cid, grade.gre AS grade_gre
FROM grade
WHERE grade.id = %s
2016-05-09 20:32:20,742 INFO sqlalchemy.engine.base.Engine (1,)
None
>>> 相關推薦
Python中使用SQLAlchemy連線Mysql資料庫（單表操作）
一，SQLAlchemy的安裝 使用 $ easy_install sqlalchemy 或 $ pip install sqlalchemy 如果出現什麼錯，就進去root使用者下進行安裝試試，或者網上查查 >>>
SQLAlchemy 連線 MySQL 資料庫（一）
一、ORM介紹 ORM 全稱 Object Relational Mapping, 翻譯過來叫物件關係對映。簡單的說，ORM 將資料庫中的表與面嚮物件語言中的類建立了一種對應關係。這樣，我們要操作資料庫，資料庫中的表或者表中的一條記錄就可以直接通過操作類或者類
使用EntityFramework6連線MySql資料庫（db first方式）
準備工具： 程式包管理器執行命令： Install-Package EntityFramework Install-Package MySql.Data.Entity.EF6Install-Package MySql.Data.Entity -Version 6.9.3 這塊已經可以直接I
使用EntityFramework6連線MySql資料庫（code first方式）
demo託管地址：http://git.oschina.net/uustudy/ASP.NET-CodeFirst-MySQL-Demo.git 首先和DB First那篇文章一樣，準備工具都要一樣的。安裝包順序也是一樣的。 web.config檔案中加入這些： <entityFramew
Flask--使用普通的方法連線MySQL資料庫（不使用ORM）
之前通過學習極客學院的視訊入門Flask的，它裡面教授連線MySQL的方法的是不使用ORM，而是通過Flask的MySQLdb模組直接連線MySQL資料庫。 它的結構是 資料庫操作：mydb.py 檢視邏輯：views.py model.py
jdbc連線mysql資料庫（或oracle）驗證通過，並操作資料庫
1.連線資料庫其實很簡單，直接粘程式碼，首先我們先複製mysql的jar包 2.再建立資料庫連線資訊檔案，寫入檔案，DRIVER可以照抄，URL是本地的資料庫資訊，如果是伺服器的資料庫可以將localhsot改成伺服器Ip，使用者名稱和密碼是資料庫的。 3.建立一個db類，第一個
python框架flask連線mysql資料庫操作
最近在用flask框架做一個python web專案,其中要連線資料庫,所以總結如下: 如何用pycharm快速建立一個flask專案我就不詳細說了,可以先建立虛擬環境,不過大部分的事pycharm都
springboot連線mysql資料庫（2）
第一步找到檢視——工具視窗——database或者在視窗的右側找到，，具體看我畫紅線部分然後點選。 第二步點選“+”然後找到Database——Mysql 點選 第三步按紅線部分分別寫入機器名，資料庫名，賬戶名，密碼，然後點選測試，出現右側Successful，說明連線成功，點選右
express+mysql+vue專案入門-express服務端連線mysql資料庫（四）
express+mysql+vue專案入門-express服務端連線mysql資料庫，此方法mysql為例：新增一個mysql連線模組並匯出，在服務端入口匯入使用即可 var mysql = req
採用C/S架構完成使用者註冊並連線Mysql資料庫（介面winform）
語言：C#開發平臺：VS2017對於C/S架構的一些基本互動我前面已經寫過了，這裡就不再贅述，C#並沒有直接連線資料庫的東西，需要匯入資料庫的外掛才能驅動資料庫操作，using MySql.Data.MySqlClient;也就是引如這個名稱空間，這個空間來自Mysql下的一
Eclipse連線MySQL資料庫（詳細步驟）
本人在寫這篇部落格的時候也是菜鳥一隻，百度“Java連線mysql資料庫、eclipse連線資料庫”等文章一大堆，可總是報錯。 下面的操作是經本人驗證，確實可行，包括了jar包匯入、用jdbc連線my
C++連線MySQL資料庫（利用API）
一般C/C++與資料庫相連有兩種方法。 利用ODBC，ADO，或者JDBC 用ODBC，ADO，JDBC等這些介面，利用裡面的方法來進行與資料庫的連線，簡化對資料庫的操作，方便對資料庫進行管理。 介面的區別可以參考以下文章 不過注意的是C/C++
Saiku連線mysql資料庫（二）
Saiku連線Mysql資料庫展示資料 參考連結：https://www.cnblogs.com/shirui/p/8573491.html 前提：Saiku已安裝好，mysql已安裝好 1.新增Saiku的資料庫驅動： mysql-connect-java-5.1.17.jar 下載
MyEcplise中java連線MySQL資料庫的java.lang.NoClassDefFoundError: org/aspectj/lang/Signature問題
我用的是ecplise3.2+myecplise5.1.1+Tomcat 5.0+MySQL5.0+jdk1.5新建專案名為Test,然後在裡面新建了mysql.html和mysql.jsp功能是把mysql.html寫的東西傳到mysql.jsp中程式如下：(2.1)mysql.html <html
連線mysql資料庫（十）
Django預設使用的是Python自帶的SQLite3，SQLite3資料庫並不適用於大型的專案。除此之外，Django還支援以下幾種資料庫： 1.PostgreSQL（http://ww
VS 中引用連線mysql資料庫失敗 報錯：">LINK : fatal error LNK1104: 無法開啟檔案“libmysql.lib”
出現此類問題時，首先需要檢查一下專案配置檔案： 專案檔案——》右鍵屬性 （1）檢查VC++目錄配置配置均完成！ （2）檢查連結器——》輸入配置方法如下： 若檢查以上錯誤均完成了，錯誤報錯原因就是不是配置專案的原因，開啟專案路徑檢查路徑下是否有如下兩個檔案“libmys
centos下 c++連線mysql資料庫（坑）
程式碼：http://download.csdn.net/detail/chuanyu/9674720 一開始真是各種坑 安裝了mysql-server ， mysql-client, mysql-devel 查找了mysql的位置 ：locate mysql
Qt4.8.7連線MySql資料庫（windows環境）
1.軟體準備 qt-opensource-windows-x86-mingw482-4.8.7.exe Qt4的最後一個版本，bug應該是最少的，其他版本也類似。官方下載連結（329M）mysql-
Eclipse連線MySQL資料庫（傻瓜篇）
本來不想寫這麼簡單人文章，在百度上搜索我這個標題，完全符合標題的一大堆。但我按照那些文章搗鼓了很久，就是不行。 我的環境：MySQL：mysql-essential-5.1.51-win32 Eclipse：任意版本，免費的，可以百度的到。
phpstorm連線mysql資料庫（超方便，超好用）
要先裝驅動，才能輸入host、user、password等，測試連線mysql。 ctrl+enter執行sql語句 執行完，匯出成csv 注意：假如，你忘了設定表頭，匯出後用notepa