Mysql 在SQL和sqlalchemy中连接和添加数据

我是MySQL和sqlalchemy的新手

因此，子查询_A以如下形式给出了约1000个结果：

 [(customer_id, days_a_customer)...]

 [(customer_id, transaction_id)...]

子查询_B以以下形式提供了约30000个结果：

 [(customer_id, days_a_customer)...]

 [(customer_id, transaction_id)...]

子查询_A表示“days_A_customer”值大于30的客户ID。子查询_B表示所有客户的事务事件

如何合并这两个子查询，以便在子查询中获得所有行，这些行在子查询中具有“customer\u id”值，并且在子查询中具有“days\u a\u customer”，即：

Subquery_C = [(customer_id, transaction_id, days_a_customer)...]

其中，子查询_C表示已存在超过30天的客户执行的所有事务事件

---

sqlalchemy特定帮助是首选，但原始SQL也将非常感谢。

基于您的问题，我猜您想要：

• 已成为客户超过30天且拥有 交易

所有客户都在一个表中，交易在一个单独的表中。为了解决这个问题，我们可以在customers和transactions表之间使用一个内部连接（只返回两个表中的记录）和filter方法来过滤作为customer的天数。下面的示例显示了此方法

from sqlalchemy import Column, Integer, String, DateTime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine, ForeignKey
from sqlalchemy.orm import sessionmaker, relationship
from random import randint

Base = declarative_base()


## Define sample models


class Customer(Base):
    __tablename__ = 'customer'
    customer_id = Column('id', Integer, primary_key=True)
    nr_days_customer = Column('nr_days_customer', Integer)
    name = Column('name', String(250))
    transaction = relationship('Transaction', back_populates='customer')

    def __init__(self, nr_days_customer, name):
        self.nr_days_customer = nr_days_customer
        self.name = name

    def __repr__(self):
        return '[{customer_id}] - {name} - {nr_days_customer} days'.format(customer_id=self.customer_id,
                                                                           name=self.name,
                                                                           nr_days_customer=self.nr_days_customer)


class Transaction(Base):
    __tablename__ = 'transaction'
    transaction_id = Column('id', Integer, primary_key=True)
    customer_id = Column('customer_id', Integer, ForeignKey('customer.id'))
    name = Column(String(250))
    customer = relationship('Customer', back_populates='transaction')

    def __init__(self, customer_id, name):
        self.customer_id = customer_id
        self.name = name

    def __repr__(self):
        return '[{transaction_id}] {name} - customer: {customer_id}'.format(transaction_id=self.transaction_id,
                                                                            name=self.name,
                                                                            customer_id=self.customer_id)


engine = create_engine('sqlite:///')
session = sessionmaker()
session.configure(bind=engine)
ex_ses = session()
Base.metadata.create_all(engine)

## Create sample data

# http://listofrandomnames.com/ for something else then A,B,...
names = ['Virgil', 'Ina', 'Oleta', 'Suzette', 'Usha', 'Ilda', 'Lorean', 'Cinthia', 'Sheba', 'Waneta', 'Donnette',
         'Minerva', 'Owen', 'Georgia', 'Gertrudis', 'Sherika', 'Terry', 'Deja', 'Regena', 'Carolin']

# Create customers > 30 days with transaction
for customer_nr in range(5):
    ex_ses.add(Customer(name=names[customer_nr].format(customer_nr),
                        nr_days_customer=randint(30, 120)))

# Create customers < 30 days with transaction
for customer_nr in range(5):
    ex_ses.add(Customer(name=names[customer_nr + 5].format(customer_nr),
                        nr_days_customer=randint(0, 29)))

# Create customers > 30 days without transaction
for customer_nr in range(5):
    ex_ses.add(Customer(name=names[customer_nr + 10].format(customer_nr),
                        nr_days_customer=randint(30, 120)))

# Create customers < 30 days without transaction
for customer_nr in range(5):
    ex_ses.add(Customer(name=names[customer_nr + 15].format(customer_nr),
                        nr_days_customer=randint(0, 29)))

# Create transactions
for transaction_nr in range(10):
    ex_ses.add(Transaction(name='Transaction {}'.format(transaction_nr), customer_id=transaction_nr + 1))

ex_ses.commit()

# Queries
print('customers:')
for customer in ex_ses.query(Customer).all():
    print('* ', customer)

'''
customers:
*  [1] - Virgil - 113 days
*  [2] - Ina - 112 days
*  [3] - Oleta - 44 days
*  [4] - Suzette - 61 days
*  [5] - Usha - 82 days
*  [6] - Ilda - 10 days
*  [7] - Lorean - 14 days
*  [8] - Cinthia - 24 days
*  [9] - Sheba - 25 days
*  [10] - Waneta - 11 days
*  [11] - Donnette - 38 days
*  [12] - Minerva - 110 days
*  [13] - Owen - 98 days
*  [14] - Georgia - 68 days
*  [15] - Gertrudis - 36 days
*  [16] - Sherika - 18 days
*  [17] - Terry - 6 days
*  [18] - Deja - 7 days
*  [19] - Regena - 21 days
*  [20] - Carolin - 14 days
'''

print('Transactions:')
for transaction in ex_ses.query(Transaction).all():
    print('* ', transaction)

'''
Transactions:
*  [1] Transaction 0 - customer: 1
*  [2] Transaction 1 - customer: 2
*  [3] Transaction 2 - customer: 3
*  [4] Transaction 3 - customer: 4
*  [5] Transaction 4 - customer: 5
*  [6] Transaction 5 - customer: 6
*  [7] Transaction 6 - customer: 7
*  [8] Transaction 7 - customer: 8
*  [9] Transaction 8 - customer: 9
*  [10] Transaction 9 - customer: 10
'''


'''
-- using inner join only records in both tables are being returned
-- https://www.w3schools.com/sql/sql_join.asp
-- condition on more then 30 days
-- untested SQL:
SELECT customer.customer_id, transaction.transaction_id, customer.days_a_customer from customer
INNER JOIN transaction ON customer.customer_id = transaction.customer_id
WHERE customer.days_a_customer > 30 AND customer.customer_id.
'''

print('Customer - transactions:')
for cust_trans in ex_ses.query(Customer.name, Customer.nr_days_customer,Transaction.transaction_id).join(Transaction).filter(
        Customer.nr_days_customer > 30).all():
    print('* Customer {customer_name} - {nr_days_customer} --> transaction {transaction_id}'.format(
        customer_name = cust_trans[0],nr_days_customer=cust_trans[1],transaction_id=cust_trans[2]))

'''
Customer - transactions:
* Customer Virgil - 113 --> transaction 1
* Customer Ina - 112 --> transaction 2
* Customer Oleta - 44 --> transaction 3
* Customer Suzette - 61 --> transaction 4
* Customer Usha - 82 --> transaction 5
'''

来自sqlalchemy导入列、整数、字符串、日期时间
从sqlalchemy.ext.declarative导入声明性基础
从sqlalchemy导入创建_引擎，ForeignKey
从sqlalchemy.orm导入sessionmaker，关系
从随机导入randint
Base=声明性_Base（）
##定义示例模型
类别客户（基本）：
__tablename_uuu=‘客户’
客户id=列（'id'，整数，主键=True）
nr_天_客户=列（'nr_天_客户'，整数）
名称=列（'name'，字符串（250））
交易=关系（'transaction'，back_填充='customer'）
定义初始（自我、天数、客户、姓名）：
self.nr\u days\u customer=nr\u days\u customer
self.name=名称
定义报告（自我）：
返回'[{customer\u id}]-{name}-{nr\u days\u customer}days'。格式（customer\u id=self.customer\u id，
name=self.name，
nr_天_客户=自身。nr_天_客户）
类事务（基本）：
__tablename_uu='transaction'
事务\u id=列（'id'，整数，主键=True）
customer\u id=列（'customer\u id'，整数，ForeignKey（'customer.id'））
名称=列（字符串（250））
客户=关系（'customer'，back_populates='transaction'）
定义初始化（自身、客户id、名称）：
self.customer\u id=customer\u id
self.name=名称
定义报告（自我）：
返回'[{transaction\u id}]{name}-customer:{customer\u id}'。格式（transaction\u id=self.transaction\u id，
name=self.name，
客户识别号=self.customer\u id）
引擎=创建引擎（'sqlite://'））
session=sessionmaker（）
配置（绑定=引擎）
ex_ses=会话（）
Base.metadata.create_all（引擎）
##创建示例数据
# http://listofrandomnames.com/ 为了别的什么，那么A，B，。。。
姓名=['Virgil'、'Ina'、'Oleta'、'Suzette'、'Usha'、'Ilda'、'Lorean'、'Cinthia'、'Sheba'、'Waneta'、'Donnette'，
“密涅瓦”、“欧文”、“乔治亚”、“格特鲁迪斯”、“谢丽卡”、“特里”、“德加”、“雷吉娜”、“卡罗琳”]
#通过交易创建>30天的客户
对于范围（5）内的客户数量：
ex_ses.add（客户（名称=名称[客户编号]）。格式（客户编号），
nr_天数_客户=randint（30，120）））
#通过交易创建<30天的客户
对于范围（5）内的客户数量：
添加（客户名称=名称[客户编号+5]。格式（客户编号），
nr_天数_客户=randint（0,29）））
#创建30天以上无交易记录的客户
对于范围（5）内的客户数量：
添加（客户名称=名称[客户编号+10]。格式（客户编号），
nr_天数_客户=randint（30，120）））
#创建30天内无交易的客户
对于范围（5）内的客户数量：
添加（客户名称=名称[客户编号+15]。格式（客户编号），
nr_天数_客户=randint（0,29）））
#创建事务
对于范围（10）内的交易数量：
ex_ses.add（事务（name='Transaction{}'。格式（事务编号），客户编号=事务编号+1））
ex_ses.commit（）
#询问
打印（'客户：'）
对于exus.query（customer.all（）中的客户：
打印（“*”，客户）
'''
客户：
*[1]-维吉尔-113天
*[2]-Ina-112天
*[3]-奥列塔-44天
*[4]-苏塞特-61天
*[5]-美国卫生署-82天
*[6]-Ilda-10天
*[7]-洛伦-14天
*[8]-辛西亚-24天
*[9]-示巴-25天
*[10]-瓦内塔-11天
*[11]-Donnette-38天
*[12]-密涅瓦-110天
*[13]-欧文-98天
*[14]-格鲁吉亚-68天
*[15]-格特鲁迪斯-36天
*[16]-谢里卡-18天
*[17]-特里-6天
*[18]-Deja-7天
*[19]-丽晶-21天
*[20]-卡罗琳-14天
'''
打印（'事务：'）
对于exus.query（transaction.all（）中的事务：
打印（“*”，事务）
'''
交易：
*[1]交易记录0-客户：1
*[2]交易1-客户：2
*[3]交易2-客户：3
*[4]交易3-客户：4
*[5]交易4-客户：5
*[6]交易记录5-客户：6
*[7]交易6-客户：7
*[8]交易记录7-客户：8
*[9]交易8-客户：9
*[10]交易记录9-客户：10
'''
'''
--使用内部联接只返回两个表中的记录
-- https://www.w3schools.com/sql/sql_join.asp
--条件超过30天
--未经测试的SQL：
从客户中选择customer.customer\u id、transaction.transaction\u id、customer.days\u a\u customer
customer.customer\u id=transaction.customer\u id上的内部联接事务
其中customer.days\u a\u customer>30和customer.customer\u id。
'''
打印（'Customer-transac