PandasとSQL：適切なツールの選択

-- SQL excels at:
-- 1. Filtering billions of rows using an index
SELECT * FROM orders WHERE customer_id = 12345;

-- 2. Joining large tables efficiently
SELECT o.order_id, c.name, SUM(o.amount)
FROM orders o
JOIN customers c ON o.customer_id = c.id
GROUP BY o.order_id, c.name;

-- 3. Window functions on ordered data
SELECT order_id, amount,
       SUM(amount) OVER (PARTITION BY customer_id ORDER BY order_date)
FROM orders;

import pandas as pd

# Pandas excels at:
# 1. Custom Python logic that SQL cannot express
df['clean_name'] = df['name'].str.strip().str.title().str.replace(r'[^a-zA-Z ]', '', regex=True)

# 2. Vectorised string parsing
df[['first', 'last']] = df['full_name'].str.split(' ', n=1, expand=True)

# 3. Rolling statistics and time series
df['7day_avg'] = df['daily_sales'].rolling(7).mean()

# 4. Direct visualisation
# df.groupby('category')['sales'].sum().plot(kind='bar')

import pandas as pd

df = pd.DataFrame({'region': ['N','S','N','E'], 'amount': [100,200,150,300]})

# SQL: SELECT region, SUM(amount) FROM df WHERE amount>100 GROUP BY region ORDER BY region
# Pandas:
result = (
    df[df['amount'] > 100]
    .groupby('region')['amount']
    .sum()
    .reset_index()
    .sort_values('region')
)
print(result)

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///large.db')

# Right approach: SQL handles the heavy lifting
summary_df = pd.read_sql_query(
    '''
    SELECT region, product_category,
           SUM(revenue) AS total_revenue,
           COUNT(DISTINCT customer_id) AS unique_customers
    FROM orders
    WHERE order_date >= '2024-01-01'
    GROUP BY region, product_category
    ''',
    con=engine
)
# summary_df is small — now do Pandas things on it
print(summary_df.sort_values('total_revenue', ascending=False))

import pandas as pd

df = pd.DataFrame({
    'date': pd.date_range('2024-01-01', periods=30),
    'sales': [100 + i*10 + (i%7)*20 for i in range(30)]
})

# Pandas rolling — easy with arbitrary window functions
df['7d_mean'] = df['sales'].rolling(7).mean()
df['7d_std']  = df['sales'].rolling(7).std()
df['7d_corr'] = df['sales'].rolling(7).corr(df['sales'].shift(1))
print(df.tail())

import pandas as pd

trades = pd.DataFrame({
    'time': pd.to_datetime(['2024-01-01 10:00', '2024-01-01 10:05', '2024-01-01 10:12']),
    'symbol': ['AAPL', 'AAPL', 'AAPL'],
    'shares': [100, 200, 50]
})
prices = pd.DataFrame({
    'time': pd.to_datetime(['2024-01-01 10:00', '2024-01-01 10:10']),
    'price': [185.0, 186.5]
})

# Fuzzy join: match each trade to the nearest preceding price
result = pd.merge_asof(trades.sort_values('time'),
                       prices.sort_values('time'),
                       on='time', direction='backward')
print(result)

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///data.db')

# Development: sample in Pandas for fast iteration
df_sample = pd.read_sql_query(
    'SELECT * FROM orders ORDER BY RANDOM() LIMIT 10000',
    con=engine
)
# Explore and prototype:
df_sample['revenue_tier'] = pd.cut(
    df_sample['amount'],
    bins=[0, 100, 500, float('inf')],
    labels=['low', 'mid', 'high']
)
print(df_sample['revenue_tier'].value_counts())
# Production: translate cut logic to SQL CASE WHEN

# pip install pandasql
import pandas as pd
# from pandasql import sqldf

df = pd.DataFrame({
    'product': ['A', 'B', 'A', 'C', 'B'],
    'sales': [100, 200, 150, 80, 220]
})

# With pandasql (commented out as it requires install):
# result = sqldf('SELECT product, SUM(sales) AS total FROM df GROUP BY product', locals())

# Equivalent native Pandas:
result = df.groupby('product')['sales'].sum().reset_index()
print(result)

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///pipeline.db')

# Step 1: SQL coarse aggregation
df = pd.read_sql_query('''
    SELECT DATE(order_date) AS date, region, SUM(amount) AS daily_revenue
    FROM orders WHERE status = 'completed'
    GROUP BY DATE(order_date), region
    ORDER BY date
''', con=engine, parse_dates=['date'])

# Step 2: Pandas rolling and pivoting (hard in SQL)
df['7d_avg'] = df.groupby('region')['daily_revenue'].transform(
    lambda x: x.rolling(7, min_periods=1).mean()
)
pivot = df.pivot(index='date', columns='region', values='7d_avg')
print(pivot.tail())