# 原始 SQL

> 原文： [http://zetcode.com/db/sqlalchemy/rawsql/](http://zetcode.com/db/sqlalchemy/rawsql/)

在 SQLite 教程的这一部分中，我们使用原始 SQL。 SQLAlchemy 并不是纯粹的 ORM 工具包。 它还允许在需要时执行原始 SQL 语句。

## 标量数据

在第一个示例中，我们连接到内存中的 SQLite 数据库并执行一个简单的 SQL 语句。

`scalar_data.py`

```py
#!/usr/bin/python
# -*- coding: utf-8 -*-

from sqlalchemy import create_engine

eng = create_engine('sqlite:///:memory:')

with eng.connect() as con:

    rs = con.execute('SELECT 5')

    data = rs.fetchone()[0]

    print "Data: %s" % data  

```

该示例打印由`SELECT`语句返回的值。

```py
eng = create_engine('sqlite:///:memory:')

```

`create_engine`方法创建一个引擎，该引擎用于将 SQL 语句传递到数据库。 该方法将连接字符串作为参数。 我们将连接到内存中的 SQLite 数据库。

```py
with eng.connect() as con:

```

使用`connect()`方法，我们连接到连接字符串中指定的数据库。

```py
rs = con.execute('SELECT 5')

```

使用连接的`execute()`方法，我们提供了一个简单的`SELECT` SQL 语句。

```py
data = rs.fetchone()[0]

```

使用`fetchone()`方法，我们检索了一行。 从这一行，我们得到标量值。

```py
print "Data: %s" % data 

```

该值将打印到控制台。

```py
$ ./scalar_data.py 
Data: 5

```

我们执行脚本。

## PostgreSQL 版本

在下一个示例中，我们连接到 PostgreSQL 数据库并打印其版本。

`postgres_version.py`

```py
#!/usr/bin/python
# -*- coding: utf-8 -*-

from sqlalchemy import create_engine

eng = create_engine('postgresql:///testdb')
con = eng.connect()

rs = con.execute("SELECT VERSION()")
print rs.fetchone()

con.close()

```

要选择数据库的版本，我们使用`SELECT VERSION()` SQL 命令。

```py
eng = create_engine('postgresql:///testdb')

```

我们连接到 PostgreSQL 中的`testdb`数据库。 我们在连接字符串中不包含用户名和密码。 这是因为 PostgreSQL 允许在其信任认证策略中对本地连接不进行认证就进行连接。

```py
rs = con.execute("SELECT VERSION()")
print rs.fetchone()

```

我们执行 SQL 命令并将返回的数据打印到控制台。

```py
$ ./postgres_version.py 
(u'PostgreSQL 9.3.9 on x86_64-unknown-linux-gnu, compiled by gcc (Ubuntu 4.8.4-2ubuntu1~14.04) 4.8.4, 64-bit',)

```

这是一个示例输出。

## 创建数据库表

在下面的示例中，我们将创建一个表并将其填充数据。

`raw_create_table.py`

```py
#!/usr/bin/python
# -*- coding: utf-8 -*-

from sqlalchemy import create_engine
from sqlalchemy.sql import text

eng = create_engine("mysql://testuser:test623@localhost/testdb")

with eng.connect() as con:

    con.execute(text('DROP TABLE IF EXISTS Cars'))
    con.execute(text('''CREATE TABLE Cars(Id INTEGER PRIMARY KEY, 
                 Name TEXT, Price INTEGER)'''))

    data = ( { "Id": 1, "Name": "Audi", "Price": 52642 },
             { "Id": 2, "Name": "Mercedes", "Price": 57127 },
             { "Id": 3, "Name": "Skoda", "Price": 9000 },
             { "Id": 4, "Name": "Volvo", "Price": 29000 },
             { "Id": 5, "Name": "Bentley", "Price": 350000 },
             { "Id": 6, "Name": "Citroen", "Price": 21000 },
             { "Id": 7, "Name": "Hummer", "Price": 41400 },
             { "Id": 8, "Name": "Volkswagen", "Price": 21600 }
    )

    for line in data:
        con.execute(text("""INSERT INTO Cars(Id, Name, Price) 
            VALUES(:Id, :Name, :Price)"""), **line)

```

使用绑定参数的后端中立方式创建`Cars`表。

```py
eng = create_engine("mysql://testuser:test623@localhost/testdb")

```

我们将连接到 MySQL 数据库。 我们使用特定的 MySQL 连接字符串。

```py
for line in data:
    con.execute(text("""INSERT INTO Cars(Id, Name, Price) 
        VALUES(:Id, :Name, :Price)"""), **line)

```

使用`for`循环，我们将数据插入数据库表中。 数据库使用不同的绑定参数构造。 借助`text()`函数，我们使用了后端中立的方式来绑定参数。

```py
$ mysql -u testuser -p
mysql> USE testdb;
mysql> SELECT * FROM Cars;
+----+------------+--------+
| Id | Name       | Price  |
+----+------------+--------+
|  1 | Audi       |  52642 |
|  2 | Mercedes   |  57127 |
|  3 | Skoda      |   9000 |
|  4 | Volvo      |  29000 |
|  5 | Bentley    | 350000 |
|  6 | Citroen    |  21000 |
|  7 | Hummer     |  41400 |
|  8 | Volkswagen |  21600 |
+----+------------+--------+
8 rows in set (0.00 sec)

```

我们验证数据。

## 列名

下面的示例打印`Cars`表的列名。

`raw_column_names.py`

```py
#!/usr/bin/python
# -*- coding: utf-8 -*-

from sqlalchemy import create_engine
from sqlalchemy.sql import text

eng = create_engine('sqlite:///:memory:')

with eng.connect() as con:

    con.execute(text('''CREATE TABLE Cars(Id INTEGER PRIMARY KEY,
        Name TEXT, Price INTEGER)'''))
    rs = con.execute(text('SELECT * FROM Cars'))

    print rs.keys()

```

该示例在内存中创建一个数据库表并打印其列名。

```py
rs = con.execute(text('SELECT * FROM Cars'))

```

在`SELECT`语句中，我们选择所有列。

```py
print rs.keys()

```

`keys()`方法返回列的名称。

```py
$ ./raw_column_names.py 
[u'Id', u'Name', u'Price']

```

这是示例的输出。

在 SQLite 教程的这一部分中，我们使用 SQLAlchemy 执行了原始 SQL 语句。