如何利用Python实现SQL自动化？

 笔者在工作中经常要使用SQL，其不乏存在恼人的细微差异和种种限制，但说到底，它是数据行业的基石。因此，对于每一位数据领域的工作者，SQL都是不可或缺的。精通SQL意义非凡。

目前创新互联已为上1000家的企业提供了网站建设、域名、网页空间、网站托管、企业网站设计、丽江网站维护等服务，公司将坚持客户导向、应用为本的策略，正道将秉承"和谐、参与、激情"的文化，与客户和合作伙伴齐心协力一起成长，共同发展。

SQL是很不错，但怎么能仅满足于“不错”呢?为什么不进一步操作SQL呢?

陈述性语句会诱发SQL限制的发生，就是说，向SQL寻求数据，SQL会在特定数据库找寻并反馈。对于许多数据提取或简单的数据操作任务来说，这已经足够了。

但如果有更多需求怎么办?

本文将为你展示如何操作。

从基础开始

 
 
 
 
    
  
  
  
  
  1. import pyodbc
    2. 
  
  
  
  
  2. from datetime import datetime
    3. 
  
  
  
  
  3. classSql:
    4. 
  
  
  
  
  4.     def__init__(self,  database, server="XXVIR00012,55000"):
    5. 
  
  
  
  
  5.         # here we are  telling python what to connect to (our SQL Server)
    6. 
  
  
  
  
  6.         self.cnxn = pyodbc.connect("Driver={SQL  Server Native Client 11.0};"
    7. 
  
  
  
  
  7.                                    "Server="+server+";"
    8. 
  
  
  
  
  8.                                    "Database="+database+";"
    9. 
  
  
  
  
  9.                                    "Trusted_Connection=yes;")
    10. 
  
  
  
  
  10.         # initialise  query attribute
    11. 
  
  
  
  
  11.         self.query ="--  {}\n\n-- Made in Python".format(datetime.now()
    12. 
  
  
  
  
  12.                                                           .strftime("%d/%m/%Y"))
    13.

这个代码就是操作MS SQL服务器的基础。只要编写好这个代码，通过Python 连接到SQL 仅需:

 
 
 
 
    
  
  
  
  
  1. sql = Sql('database123')
    2.

很简单对么?同时发生了几件事，下面将对此代码进行剖析。class Sql:

首先要注意，这个代码包含在一个类中。笔者发现这是合乎逻辑的，因为在此格式中，已经对此特定数据库进行了增添或移除进程。若见其工作过程，思路便能更加清晰。

初始化类:

 
 
 
 
    
  
  
  
  
  1. def __init__(self, database,server="XXVIR00012,55000"):
    2.

因为笔者和同事几乎总是连接到相同的服务器，所以笔者将这个通用浏览器的名称设为默认参数server。

在“Connect to Server”对话框或者MS SQL Server Management Studio的视窗顶端可以找到服务器的名称：

下一步，连接SQL:

 
 
 
 
    
  
  
  
  
  1. self.cnxn =pyodbc.connect("Driver={SQL Server Native Client 11.0};"
    2. 
  
  
  
  
  2.                           "Server="+self.server+";"
    3. 
  
  
  
  
  3.                           "Database="+self.database+";"
    4. 
  
  
  
  
  4.                           "Trusted_Connection=yes;")
    5.

pyodbc 模块，使得这一步骤异常简单。只需将连接字符串过渡到 pyodbc.connect(...) 函数即可，点击以了解详情here。

最后，笔者通常会在 Sql 类中编写一个查询字符串，sql类会随每个传递给类的查询而更新:

 
 
 
 
    
  
  
  
  
  1. self.query = "-- {}\n\n--Made in Python".format(datetime.now()
    2. 
  
  
  
  
  2.                                              .strftime("%d/%m/%Y"))
    3.

这样便于记录代码，同时也使输出更为可读，让他人读起来更舒服。

请注意在下列的代码片段中，笔者将不再更新代码中的self.query 部分。

组块

一些重要函数非常有用，笔者几乎每天都会使用。这些函数都侧重于将数据从数据库中传入或传出。

以下图文件目录为始:

对于当前此项目，需要:

  • 将文件导入SQL
  • 将其合并到单一表格内
  • 根据列中类别灵活创建多个表格

SQL类不断被充实后，后续会容易很多:

 
 
 
 
    
  
  
  
  
  1. import sys
    2. 
  
  
  
  
  2. sys.path.insert(0, r'C:\\User\medium\pysqlplus\lib')
    3. 
  
  
  
  
  3. import os
    4. 
  
  
  
  
  4. from data importSql
    5. 
  
  
  
  
  5. sql =Sql('database123')  # initialise the Sql object
    6. 
  
  
  
  
  6. directory =r'C:\\User\medium\data\\'  # this is where our generic data is  stored
    7. 
  
  
  
  
  7. file_list = os.listdir(directory)  # get a list of all files
    8. 
  
  
  
  
  8. for file in  file_list:  # loop to import  files to sql
    9. 
  
  
  
  
  9.     df = pd.read_csv(directory+file)  # read file to dataframe
    10. 
  
  
  
  
  10.     sql.push_dataframe(df, file[:-4])
    11. 
  
  
  
  
  11. # now we  convert our file_list names into the table names we have imported to SQL
    12. 
  
  
  
  
  12. table_names = [x[:-4] for x in file_list]
    13. 
  
  
  
  
  13. sql.union(table_names, 'generic_jan')  # union our files into one new table  called 'generic_jan'
    14. 
  
  
  
  
  14. sql.drop(table_names)  # drop our original tables as we now  have full table
    15. 
  
  
  
  
  15. # get list of  categories in colX, eg ['hr', 'finance', 'tech', 'c_suite']
    16. 
  
  
  
  
  16. sets =list(sql.manual("SELECT  colX AS 'category' FROM generic_jan GROUP BY colX", response=True)['category'])
    17. 
  
  
  
  
  17. for category in sets:
    18. 
  
  
  
  
  18.     sql.manual("SELECT *  INTO generic_jan_"+category+" FROM  generic_jan WHERE colX = '"+category+"'")
    19.

从头开始。

入栈数据结构

 
 
 
 
    
  
  
  
  
  1. defpush_dataframe(self, data,  table="raw_data", batchsize=500):
    2. 
  
  
  
  
  2.     # create execution cursor
    3. 
  
  
  
  
  3.     cursor = self.cnxn.cursor()
    4. 
  
  
  
  
  4.     # activate fast execute
    5. 
  
  
  
  
  5.     cursor.fast_executemany =True
    6. 
  
  
  
  
  6.     # create create table statement
    7. 
  
  
  
  
  7.     query ="CREATE  TABLE ["+ table +"] (\n"
    8. 
  
  
  
  
  8.     # iterate through each column to be  included in create table statement
    9. 
  
  
  
  
  9.     for i inrange(len(list(data))):
    10. 
  
  
  
  
  10.         query +="\t[{}]  varchar(255)".format(list(data)[i])  # add column (everything is varchar  for now)
    11. 
  
  
  
  
  11.         # append correct  connection/end statement code
    12. 
  
  
  
  
  12.         if i !=len(list(data))-1:
    13. 
  
  
  
  
  13.             query +=",\n"
    14. 
  
  
  
  
  14.         else:
    15. 
  
  
  
  
  15.             query +="\n);"
    16. 
  
  
  
  
  16.     cursor.execute(query)  # execute the create table statement
    17. 
  
  
  
  
  17.     self.cnxn.commit()  # commit changes
    18. 
  
  
  
  
  18.     # append query to our SQL code logger
    19. 
  
  
  
  
  19.     self.query += ("\n\n--  create table\n"+ query)
    20. 
  
  
  
  
  20.     # insert the data in batches
    21. 
  
  
  
  
  21.     query = ("INSERT  INTO [{}] ({})\n".format(table,
    22. 
  
  
  
  
  22.                                                '['+'], ['  # get columns
    23. 
  
  
  
  
  23.                                                .join(list(data)) +']') +
    24. 
  
  
  
  
  24.              "VALUES\n(?{})".format(",  ?"*(len(list(data))-1)))
    25. 
  
  
  
  
  25.     # insert data into target table in  batches of 'batchsize'
    26. 
  
  
  
  
  26.     for i inrange(0, len(data), batchsize):
    27. 
  
  
  
  
  27.         if i+batchsize >len(data):
    28. 
  
  
  
  
  28.             batch = data[i: len(data)].values.tolist()
    29. 
  
  
  
  
  29.         else:
    30. 
  
  
  
  
  30.             batch = data[i: i+batchsize].values.tolist()
    31. 
  
  
  
  
  31.         # execute batch  insert
    32. 
  
  
  
  
  32.         cursor.executemany(query, batch)
    33. 
  
  
  
  
  33.         # commit insert  to SQL Server
    34. 
  
  
  
  
  34.         self.cnxn.commit()
    35.

此函数包含在SQL类中，能轻松将Pandas dataframe插入SQL数据库。

其在需要上传大量文件时非常有用。然而，Python能将数据插入到SQL的真正原因在于其灵活性。

要横跨一打Excel工作簿才能在SQL中插入特定标签真的很糟心。但有Python在，小菜一碟。如今已经构建起了一个可以使用Python读取标签的函数，还能将标签插入到SQL中。

Manual(函数)

 
 
 
 
    
  
  
  
  
  1. defmanual(self, query,  response=False):
    2. 
  
  
  
  
  2.     cursor = self.cnxn.cursor()  # create execution cursor
    3. 
  
  
  
  
  3.     if response:
    4. 
  
  
  
  
  4.         returnread_sql(query,  self.cnxn)  # get sql query  output to dataframe
    5. 
  
  
  
  
  5.     try:
    6. 
  
  
  
  
  6.         cursor.execute(query)  # execute
    7. 
  
  
  
  
  7.     except pyodbc.ProgrammingErroras error:
    8. 
  
  
  
  
  8.         print("Warning:\n{}".format(error))  # print error as a warning
    9. 
  
  
  
  
  9.     self.cnxn.commit()  # commit query to SQL Server
    10. 
  
  
  
  
  10.     return"Query  complete."
    11.

此函数实际上应用在union 和 drop 函数中。仅能使处理SQL代码变得尽可能简单。

response参数能将查询输出解压到DataFrame。generic_jan 表中的colX ，可供摘录所有独特值，操作如下:

 
 
 
 
    
  
  
  
  
  1. sets =list(sql.manual("SELECT colX AS 'category' FROM generic_jan GROUP BYcolX", response=True)['category'])
    2.

Union(函数)

构建 了manual 函数,创建 union 函数就简单了:

 
 
 
 
    
  
  
  
  
  1. defunion(self,  table_list, name="union", join="UNION"):
    2. 
  
  
  
  
  2.     # initialise the query
    3. 
  
  
  
  
  3.     query ="SELECT *  INTO ["+name+"] FROM (\n"
    4. 
  
  
  
  
  4.     # build the SQL query
    5. 
  
  
  
  
  5.     query +=f'\n{join}\n'.join(
    6. 
  
  
  
  
  6.                         [f'SELECT [{x}].* FROM [{x}]'for x in table_list]
    7. 
  
  
  
  
  7.                         )
    8. 
  
  
  
  
  8.     query +=")  x"  # add end of  query
    9. 
  
  
  
  
  9.     self.manual(query, fast=True)  # fast execute
    10.

创建 union 函数只不过是在循环参考 table_list提出的表名，从而为给定的表名构建 UNION函数查询。然后用self.manual(query)处理。

Drop(函数)

上传大量表到SQL服务器是可行的。虽然可行，但会使数据库迅速过载。 为解决这一问题，需要创建一个drop函数:

 
 
 
 
    
  
  
  
  
  1. defdrop(self,  tables):
    2. 
  
  
  
  
  2.     # check if single or list
    3. 
  
  
  
  
  3.     ifisinstance(tables, str):
    4. 
  
  
  
  
  4.         # if single  string, convert to single item in list for for-loop
    5. 
  
  
  
  
  5.         tables = [tables]
    6. 
  
  
  
  
  6.     for table in tables:
    7. 
  
  
  
  
  7.         # check for  pre-existing table and delete if present
    8. 
  
  
  
  
  8.         query = ("IF  OBJECT_ID ('["+table+"]', 'U')  IS NOT NULL "
    9. 
  
  
  
  
  9.                  "DROP TABLE  ["+table+"]")
    10. 
  
  
  
  
  10.         self.manual(query)  # execute
    11.

view rawpysqlplus_drop_short.py hosted with by GitHub

点击

https://gist.github.com/jamescalam/b316c1714c30986fff58c22b00395cc0

得全图

同样，此函数也由于 manual 函数极为简单。操作者可选择输入字符到tables ，删除单个表，或者向tables提供一列表名，删除多个表。

当这些非常简单的函数结合在一起时，便可以利用Python的优势极大丰富SQL的功能。

笔者本人几乎天天使用此法，其简单且十分有效。

希望能够帮助其他用户找到将Python并入其SQL路径的方法，感谢阅读!

本文标题：如何利用Python实现SQL自动化？
文章路径：http://www.shufengxianlan.com/qtweb/news45/234295.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

关键词优化知识

各行业网站

重庆电商网站建设　　 　成都营销型网站建设　　 　德阳电信机房　　 　达州网站建设　　 　成都富士康招工　　 　网站建设方案　　 　成都微信小程序开发　　 　成都营销网站建设　　 　网站设计制作　　 　营山网站建设　　 　成都标识标牌设计制作　　 　化妆品企业网站建设方案　　 　东方电机技改服务有限公司　　 　什邡做网站　　 　成都建站　　 　和正兴机械　　 　响应式网站　　 　成都茶叶销售　　 　衣柜书柜酒柜定制　　 　重庆水土双线托管