Python

mysql

使用pymysql操作，連接主要配置參數：
config = {
'host': "host",
'port': 3306,
'database': "database",
'user': "user",
'password': "password"
}

# 使用pymysql庫。
import pymysql

# 配置連接參數
config = {
    'host': "host",
    'port': 3306,
    'database': "database",
    'user': "user",
    'password': "password"
}


# 連接mysql
def mysql_conn(config):
    conn = pymysql.connect(**config)
    return conn


# mysql操作,查詢
def get_mysql_data(conn, query: str):
    # 先創建cursor負責操作conn接口
    cursor = conn.cursor()
    try:
        # 執行sql操作，可以使用executemany批量操作
        cursor.execute(query)
        # 返回多個元組，即返回多條記錄(rows),如果沒有結果,則返回 (),fetchone返回單個記錄。
        res = cursor.fetchall()
        cursor.close()
        conn.close()
    except Exception as e:
        print("mysql查詢失敗")
        cursor.close()
        conn.close()
    return res

# mysql操作,插入


def insert_data(conn, df):
    # 先創建cursor負責操作conn接口
    cursor = conn.cursor()
    # 先構造需要的或是和數據庫相匹配的列
    columns = list(df.columns)
    # 可以刪除不要的列或者數據庫沒有的列名
    columns.remove("列名")
    # 重新構造df,用上面的columns,到這里你要保證你所有列都要準備往數據庫寫入了
    new_df = df[columns].copy()

    # 構造符合sql語句的列，因為sql語句是帶有逗號分隔的,(這個對應上面的sql語句的(column1, column2, column3))
    columns = ','.join(list(new_df.columns))

    # 構造每個列對應的數據，對應于上面的((value1, value2, value3))
    data_list = [tuple(i) for i in new_df.values]  # 每個元組都是一條數據，根據df行數生成多少元組數據

    # 計算一行有多少value值需要用字符串占位
    s_count = len(data_list[0]) * "%s,"

    # 構造sql語句
    insert_sql = "insert into " + "數據庫表名" + \
        " (" + columns + ") values (" + s_count[:-1] + ")"
    try:
        cursor.executemany(insert_sql, data_list)
        cursor.close()
        conn.close()
    except Exception as e:
        print("mysql插入失敗")
        cursor.close()
        conn.close()


if __name__ == '__main__':
    conn = mysql_conn(config)
    query = "select * from database limit 1"
    res = get_mysql_data(conn, query)

    import pandas as pd
    df = pd.DataFrame()
    insert_data(conn, df)

Hbase

使用happybase庫，以下代碼測試分spark df 和 本地python格式數據寫入以及簡單讀取hbase：

# -*- coding:UTF-8 -*-
import happybase
from pyspark.sql import SparkSession
# 設置日志輸出
import logging
s_logger = logging.getLogger('py4j.java_gateway')
s_logger.setLevel(logging.ERROR)

# 設置spark連接方式，local模式可讀取本地文件
spark = SparkSession.builder.master("local") \
    .appName("hbase_wr") \
    .getOrCreate()

# happybase操作類
class Happybase_ope:
# 初始化連接參數
    def __init__(self, host="host", timeout=None, table_prefix=None):
        self.connection = happybase.Connection(
            host=host, timeout=timeout, table_prefix=table_prefix)
 # 建表
    def createTable(self, tablename, families):
        self.connection.create_table(tablename, families)
# 連接表
    def table(self, tablename):
        return self.connection.table(tablename)
# 關閉連接
    def close(self):
        self.connection.close()

# spark df 批量寫入
def WriteDF(num):
    hpbase = Happybase_ope()
    tbname = 'tbname'
    table = hpbase.table(tbname)
    # 分批寫入
    bat = table.batch()
    bat.put(row=num[0][0], data={'info:data': num[0][1]})
    bat.send()
    hpbase.close()

# 寫入一條數據
def WriteData(row,data):
    hpbase = Happybase_ope()
    tbname = 'tbname'
    table = hpbase.table(tbname)
    table.put(row=row, data=data)
    hpbase.close()

# 獲取數據
def getData():
    hpbase = Happybase_ope()
    tbname = 'tbname'
    table = hpbase.table(tbname)
    # 指定行和列族獲取數據
    res = table.row(row="info:data", columns="ent_name_hash_code1")
    return res


if __name__ == '__main__':
    result = spark.read.csv(
        'FilePath',
        header=True)
    
    result_rdd = result.rdd
    result_rdd.zipWithIndex().repartition(
        100).foreach(lambda zipArr: WriteDF(zipArr))

Solr

使用pysolr庫連接solr獲取數據

import pysolr as pl
solr = pl.Solr('solr查詢頁面地址',timeout=500000)
# rows為批量讀取行數
def get_solr_data(solr,rows=200, timeout=100):
    # 游標
    current_cursor = "*"
    # 狀態判斷是否還有數據
    has_more = True
    results = []
    # 查詢數據數量
    count = solr.search('*:*', **{'fq':'fq'}).hits
    while has_more:
        try:
            result =  solr.search('q', **{'fq':'fq','fl':'fl', "rows": rows,'sort': 'ID asc',
                                         "cursorMark": current_cursor},  timeout=timeout)
            if current_cursor == result.nextCursorMark:
                has_more = False
            else:
                current_cursor = result.nextCursorMark
            if result.docs:
                results.extend(result.docs)
        except Exception as e:
            print(e)
        finally:
            print(str(len(results)) + "/" + str(count))

    return results
data = get_solr_data(solr)

MongoDB

使用Pymongo連接mongo數據庫進行增刪改查

from pymongo import MongoClient

#創建數據庫需要使用 MongoClient 對象，并且指定連接的 URL 地址和要創建的數據庫名。
myclient = pymongo.MongoClient("mongodb://localhost:27017/")
#連接數據庫
mydb = myclient["testdb"]
#連接表
mycol = mydb["testtabel"]

增

# 增加數據，mongo插入數據為字典格式,以"_id"為主鍵，如果插入數據中沒有設置"_id",則會自己生成唯一id
mydict = {"name": "test", "sex": "男"}
mylists = [{"name": "test", "sex": "男"},
           {"name": "test1", "sex": "女"}]
# 插入一條數據
mycol.insert_one(mydict) 
# 插入多條數據
mycol.insert_many(mylist)

查

# 查詢數據

# 獲取第一條數據
mycol.find_one()

# 獲取所有數據，find返回出來的數據是一個迭代器，需for循環使用或轉為list等類型。
list(mycol.find())

# 條件查詢,指定字典類型查詢即可
query = {"name": "test"}
query1 = {"name": "test","sex": "男"}
mycol.find_one(query)
mycol.find_one(query1,{"name":1})  # {"name":1}表示只返回name列

改

# 修改數據

# 修改匹配到的第一條數據，update方法第一個參數為查詢條件，第二個參數為修改字段。
myquery = { "name": "test" }
newvalues = { "$set": { "sex": "nan" } }
mycol.update_one(myquery, newvalues)
# 批量修改用many方法。
mycol.update_many(myquery, newvalues)

刪

# 刪除數據

# 條件刪除,指定字典類型查詢即可
query = {"name": "test"}
query1 = {"name": "test","sex": "男"}
# 刪除匹配到的第一條數據
mycol.delete_one(query)
# 刪除所有匹配到的數據
mycol.delete_many(query1)

批量更新

# 批量操作
# bulk_write(requests, ordered=True, bypass_document_validation=False, session=None)
# requests：一個包含寫操作示例的列表（InsertOne, UpdateOne, UpdateMany, ReplaceOne, DeleteOne, or DeleteMany）；
# ordered：表示是否順序寫入，設為True時其中的操作順序執行，中間出錯則后續操作都不會執行；設為False則所有的操作亂序執行，其中一個操作出錯其余的操作不會受影響
from pymongo import ReplaceOne
# 一個批量更新方法
def upsert_mongo_data(data,batch_size = 200):
    bulk_list = []
    for da in data:
        doc = {"_id":id;
                "name":da["name"];
                "sex":da["sex"]
        }
        bulk_list.append(ReplaceOne({"_id":doc["_id"]},doc ,upsert = True))
        if len(bulk_list) < batch_size:
            continue
        mycol.bulk_write(bulk_list)
        bulk_list = []
    if bulk_list:
        mycol.bulk_write(bulk_list)
        
mylists = [{"name": "test", "sex": "男"},
           {"name": "test1", "sex": "女"}]

upsert_mongo_data(mylists)

SPARK

kudu

利用sparksession的read和write方法讀取以及寫入，需要設置用戶和kudu表名，讀取后數據格式為spark df。

from pyspark.sql import SparkSession

# 設置spark連接方式，local模式可讀取本地文件
spark = SparkSession.builder.master("yarn") \
    .appName("xytest") \
    .getOrCreate()

# 讀入kudu數據
data = spark.read.format("org.apache.kudu.spark.kudu")
        .option("kudu.table", "impala::test_tabel")
        .option("kudu.master", "master:7051")
        .option("kudu.operation.timeout.ms", "100000")
        .load()
        
# spark df 寫入kudu表       
spark_df.write.format('org.apache.kudu.spark.kudu') \
    .option("kudu.table", "impala::test_tabel") \
    .option("kudu.master", "master:7051") \
    .mode('append') \
    .save()

hive

利用sparksession的sql和write方法讀取以及寫入，可直接讀取平臺上的hive數據庫，讀取后數據格式為spark df。

from pyspark.sql import SparkSession

# 設置spark連接方式，local模式可讀取本地文件
spark = SparkSession.builder.master("yarn") \
    .appName("xytest") \
    .getOrCreate()

#hive讀取，直接spark.sql
data = spark.sql('select * from db.tabel')

# spark df 寫入hive表
spark_df.write.format("parquet").mode("overwrite").saveAsTable(hive_tabel)

hbase

有問題，后續解決補充。。。。。。

MongoDB

import os
from pyspark.sql import SparkSession
# set PYSPARK_PYTHON to python36
os.environ['PYSPARK_PYTHON'] = '/usr/bin/python36'
# load mongodb data # 格式是："mongodb://127.0.0.1:database.collection"
input_uri = "mongodb://127.0.0.1:27017/spark.spark_test"
output_uri = "mongodb://127.0.0.1:27017/spark.spark_test"
# 創建spark，默認使用本地環境，或者"spark://master:7077"
spark = SparkSession.builder.master("local").appName("MyApp") \
        .config("spark.mongodb.input.uri",input_uri) \
        .config("spark.mongodb.output.uri", output_uri) \
        .config('spark.jars.packages', 'org.mongodb.spark:mongo-spark-connector_2.11:2.2.0') \
        .getOrCreate()
#collection:表名    pipeline:查詢條件
df_1 = spark.read.format('com.mongodb.spark.sql.DefaultSource') \
        .option("collection", tabel) \
        .option("pipeline", query).load()