Python, NumPy
and Pandas

print("Hello")
print("Total:", 25)
print("a", "b", sep="-")

# name = input("Enter name: ")
# Whatever the user types comes back as TEXT
name = "Rahul"          # pretend this came from input()
print(name, type(name))

age_text = "25"                 # input() always gives text
age = int(age_text)
print(age + 5)

print(type(10))
print(type(3.5))
print(type("hi"))
print(type(True))

print(int("42"))
print(int(9.87))

print(float("3.5"))
print(float(10))

print(str(99) + " marks")

print(bool(1), bool(0))
print(bool("hi"), bool(""))
print(bool([]), bool([1]))

print(round(3.7))
print(round(3.14159, 2))

print(abs(-15))
print(abs(15))

a, b = 17, 5
print(a + b, a - b, a * b)
print(a / b)      # normal division -> decimal
print(a // b)     # floor division  -> whole number
print(a % b)      # remainder
print(a ** 2)     # power

print(5 > 3, 5 == 5, 5 != 3)
print(5 <= 4)

age = 22
print(age > 18 and age < 30)
print(age < 18 or age > 20)
print(not (age == 22))

s = "Data Analytics"
print(len(s))

s = "Data"
print(s.upper())
print(s.lower())

s = "rahul kumar sharma"
print(s.title())
print(s.capitalize())

s = "   Rahul   "
print("[" + s.strip() + "]")
print("[" + s.lstrip() + "]")
print("[" + s.rstrip() + "]")

s = "Rahul,Priya,Amit"
print(s.split(","))
print("a b c".split())

names = ["Rahul", "Priya", "Amit"]
print(", ".join(names))
print("-".join("abc"))

s = "I like tea"
print(s.replace("tea", "coffee"))

s = "Data Analytics"
print(s.find("Analy"))
print(s.find("Python"))

s = "banana"
print(s.count("a"))

f = "report.csv"
print(f.endswith(".csv"))
print(f.startswith("rep"))

print("12345".isdigit())
print("abc".isalpha())
print("abc123".isalpha())

s = "Data Analytics"
print(s[0])
print(s[0:4])
print(s[5:])
print(s[-1])
print(s[::-1])   # reversed

name, marks = "Rahul", 87
print(f"{name} scored {marks} marks")
print(f"Average: {87/3:.2f}")

print("{} scored {}".format("Rahul", 87))

nums = [10, 20, 30]
mixed = [1, "two", 3.0, True]
empty = []
print(nums, mixed, empty)

nums = [10, 20, 30, 40, 50]
print(nums[0])
print(nums[-1])
print(nums[1:4])
print(nums[::2])

nums = [1, 2]
nums.append(3)
print(nums)
nums.append([4, 5])      # adds the whole list as one item
print(nums)

nums = [1, 2]
nums.extend([3, 4])
print(nums)

nums = [10, 30]
nums.insert(1, 20)
print(nums)

nums = [10, 20, 30, 20]
nums.remove(20)
print(nums)

nums = [10, 20, 30]
last = nums.pop()
first = nums.pop(0)
print(last, first, nums)

nums = [30, 10, 20]
nums.sort()
print(nums)
nums.sort(reverse=True)
print(nums)

nums = [30, 10, 20]
new = sorted(nums)
print(new)
print(nums)      # unchanged

nums = [1, 2, 3]
nums.reverse()
print(nums)

nums = [10, 20, 10, 30]
print(nums.count(10))
print(nums.index(20))

nums = [10, 20, 30, 40]
print(len(nums), sum(nums))
print(min(nums), max(nums))
print(sum(nums) / len(nums))     # average

a = [1, 2, 3]
b = a              # SAME list
c = a.copy()       # NEW list
a.append(4)
print(b)
print(c)

nums = [1, 2, 3, 4, 5]
squares = [n * n for n in nums]
evens   = [n for n in nums if n % 2 == 0]
print(squares)
print(evens)

t = (10, 20, 30)
print(t, len(t), t[0])

t = (1, 2, 3)
try:
    t[0] = 99
except TypeError as e:
    print("Error:", e)

point = (10, 20)
x, y = point
print(x, y)

student = {"name": "Rahul", "marks": 87, "city": "Bangalore"}
print(student)
print(student["name"])

d = {"a": 1}
d["b"] = 2          # add
d["a"] = 99         # change
print(d)

d = {"a": 1}
print(d.get("a"))
print(d.get("z"))
print(d.get("z", 0))

d = {"a": 1, "b": 2}
print(list(d.keys()))
print(list(d.values()))
print(list(d.items()))

marks = {"Rahul": 87, "Priya": 92}
for name, m in marks.items():
    print(name, "scored", m)

d = {"a": 1, "b": 2}
d.pop("a")
print(d)

d = {"a": 1}
d.update({"b": 2, "c": 3})
print(d)

s = {1, 2, 2, 3, 3, 3}
print(s)
print(set([10, 20, 10]))

s = {1, 2}
s.add(3)
s.remove(1)
print(s)

a = {1, 2, 3}
b = {3, 4, 5}
print(a | b)      # union - everything
print(a & b)      # intersection - common
print(a - b)      # difference - only in a

names = ["Rahul", "Priya", "Rahul", "Amit"]
print(list(set(names)))

marks = 78
if marks >= 90:
    print("A grade")
elif marks >= 75:
    print("B grade")
else:
    print("C grade")

names = ["Rahul", "Priya"]
print("Rahul" in names)
print("Amit" in names)
print("ta" in "Data")

for name in ["Rahul", "Priya"]:
    print("Hello", name)

print(list(range(5)))
print(list(range(2, 6)))
print(list(range(0, 10, 2)))
for i in range(3):
    print(i)

count = 1
while count <= 3:
    print(count)
    count = count + 1

for i in range(6):
    if i == 4:
        break
    if i % 2 == 0:
        continue
    print(i)

names = ["Rahul", "Priya"]
for i, name in enumerate(names):
    print(i, name)

names = ["Rahul", "Priya"]
marks = [87, 92]
for n, m in zip(names, marks):
    print(n, m)

def greet(name):
    return "Hello " + name

print(greet("Rahul"))

def add(a, b):
    return a + b

def add_no_return(a, b):
    total = a + b        # nothing sent back

print(add(2, 3))
print(add_no_return(2, 3))

def greet(name, greeting="Hello"):
    return greeting + " " + name

print(greet("Rahul"))
print(greet("Priya", "Good morning"))

def total(*nums):
    return sum(nums)

print(total(1, 2))
print(total(1, 2, 3, 4, 5))

def show(**info):
    for k, v in info.items():
        print(k, "=", v)

show(name="Rahul", city="Bangalore")

square = lambda x: x * x
print(square(5))

pairs = [(1, "b"), (3, "a"), (2, "c")]
print(sorted(pairs, key=lambda p: p[1]))

nums = [1, 2, 3]
print(list(map(lambda x: x * 10, nums)))
print(list(map(str, nums)))

nums = [1, 2, 3, 4, 5, 6]
print(list(filter(lambda x: x % 2 == 0, nums)))

with open("demo.txt", "w") as f:
    f.write("Line one\n")
    f.write("Line two\n")
print("file written")

with open("demo.txt", "w") as f:
    f.write("Line one\nLine two\n")

with open("demo.txt", "r") as f:
    print(f.read())

with open("demo.txt", "w") as f:
    f.write("a\nb\nc\n")

with open("demo.txt") as f:
    lines = f.readlines()
print(lines)
print([l.strip() for l in lines])

with open("demo.txt", "w") as f:
    f.write("first\n")
with open("demo.txt", "a") as f:
    f.write("second\n")
with open("demo.txt") as f:
    print(f.read())

try:
    x = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")

try:
    n = int("abc")
except ValueError as e:
    print("Error:", e)

try:
    print("trying")
except:
    print("failed")
finally:
    print("always runs")

class Student:
    def __init__(self, name, marks):
        self.name = name
        self.marks = marks

s = Student("Rahul", 87)
print(s.name, s.marks)

class Student:
    def __init__(self, name, marks):
        self.name = name
        self.marks = marks
    def grade(self):
        return "Pass" if self.marks >= 40 else "Fail"

s = Student("Rahul", 87)
print(s.grade())

class Person:
    def __init__(self, name):
        self.name = name
    def greet(self):
        return "Hi, I am " + self.name

class Student(Person):
    def study(self):
        return self.name + " is studying"

s = Student("Rahul")
print(s.greet())
print(s.study())

import math
print(math.sqrt(16))
print(math.pi)

from math import sqrt, floor
print(sqrt(25), floor(3.9))

import math as m
print(m.sqrt(9))

import random
random.seed(1)               # seed makes it repeatable
print(random.randint(1, 10))
print(random.choice(["a", "b", "c"]))

a = np.array([10, 20, 30])
print(a)
print(type(a))

b = np.array([[1, 2, 3],
              [4, 5, 6]])
print(b)
print(b.shape)     # (rows, columns)

print(np.zeros(4))
print(np.zeros((2, 3)))

print(np.ones(3))
print(np.ones((2, 2)))

print(np.full(4, 7))
print(np.full((2, 2), 9))

print(np.eye(3))
print(np.identity(2))

print(np.arange(5))
print(np.arange(2, 10, 2))

print(np.linspace(0, 10, 5))
print(np.linspace(0, 1, 3))

np.random.seed(1)
print(np.random.rand(3))
print(np.random.rand(2, 2))

np.random.seed(1)
print(np.random.randint(1, 100, 5))

np.random.seed(42)
print(np.random.randint(1, 10, 4))
np.random.seed(42)
print(np.random.randint(1, 10, 4))     # same again

a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.shape)
print(np.array([1,2,3,4]).shape)

print(np.array([1, 2, 3]).ndim)
print(np.array([[1, 2], [3, 4]]).ndim)

a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.size)

print(np.array([1, 2, 3]).dtype)
print(np.array([1.5, 2.5]).dtype)
print(np.array(["a", "b"]).dtype)

a = np.array([1.7, 2.9, 3.1])
print(a.astype(int))
print(np.array([1, 0, 1]).astype(bool))

a = np.array([10, 20, 30, 40])
print(a[0])
print(a[-1])

a = np.array([10, 20, 30, 40, 50])
print(a[1:4])
print(a[:3])
print(a[::2])

b = np.array([[1, 2, 3],
              [4, 5, 6]])
print(b[0, 2])
print(b[1, 0])

b = np.array([[1, 2, 3],
              [4, 5, 6]])
print(b[0, :])      # first row
print(b[:, 1])      # second column
print(b[:, 0:2])    # first two columns

a = np.array([10, 25, 3, 40, 7])
print(a > 20)
print(a[a > 20])

a = np.array([10, 25, 3, 40, 7])
print(a[(a > 5) & (a < 30)])
print(a[(a < 5) | (a > 35)])

a = np.array([10, 20, 30, 40, 50])
print(a[[0, 2, 4]])

a = np.arange(6)
print(a)
print(a.reshape(2, 3))
print(a.reshape(3, 2))

a = np.arange(6)
print(a.reshape(-1, 2))
print(a.reshape(2, -1))

b = np.array([[1, 2], [3, 4]])
print(b.ravel())
print(b.flatten())

b = np.array([[1, 2, 3], [4, 5, 6]])
print(b)
print(b.T)

a = np.array([1, 2])
b = np.array([3, 4])
print(np.concatenate([a, b]))

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(np.vstack([a, b]))

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(np.hstack([a, b]))

a = np.arange(6)
print(np.split(a, 3))

a = np.array([10, 20, 30])
print(a + 5)
print(a * 2)
print(a / 10)
print(a ** 2)

a = np.array([1, 2, 3])
b = np.array([10, 20, 30])
print(a + b)
print(a * b)

a = np.array([1, 4, 9, 16])
print(np.sqrt(a))
print(np.round(np.log(np.array([1.0, 2.718])), 2))

a = np.array([1.2, 2.7, 3.5])
print(np.round(a))
print(np.floor(a))
print(np.ceil(a))

b = np.array([[1, 2, 3],
              [4, 5, 6]])
print(b + np.array([10, 20, 30]))
print(b * 2)

a = np.array([10, 20, 30])
print(a.sum())
print(np.sum(a))

a = np.array([10, 20, 30, 100])
print(a.mean())
print(np.median(a))

a = np.array([10, 20, 30, 40])
print(round(a.std(), 2))
print(a.var())

a = np.array([10, 5, 30])
print(a.min(), a.max())

a = np.array([10, 5, 30])
print(a.argmin())
print(a.argmax())

b = np.array([[1, 2, 3],
              [4, 5, 6]])
print(b.sum())          # everything
print(b.sum(axis=0))    # down each column
print(b.sum(axis=1))    # across each row

a = np.array([10, 20, 30])
print(a.cumsum())

a = np.array([1, 2, 3, 4])
print(a.prod())

a = np.array([10, 25, 3, 40])
print(np.where(a > 20, "high", "low"))
print(np.where(a > 20, a, 0))

a = np.array([30, 10, 20])
print(np.sort(a))

a = np.array([30, 10, 20])
print(np.argsort(a))

a = np.array([3, 1, 2, 3, 1])
print(np.unique(a))
print(np.unique(a, return_counts=True))

a = np.array([10, 25, 3])
print((a > 20).any())
print((a > 20).all())

a = np.array([1.0, np.nan, 3.0])
print(np.isnan(a))
print(a[~np.isnan(a)])      # ~ means NOT

s = pd.Series([10, 20, 30])
print(s)
print(s[0], s.sum())

s = pd.Series([87, 92], index=['Rahul', 'Priya'])
print(s)
print(s['Rahul'])

data = {'name': ['Rahul', 'Priya'], 'marks': [87, 92]}
d = pd.DataFrame(data)
print(d)

rows = [['Rahul', 87], ['Priya', 92]]
d = pd.DataFrame(rows, columns=['name', 'marks'])
print(d)

df.to_csv('demo.csv', index=False)      # make a file first
d = pd.read_csv('demo.csv')
print(d.head(3))

df.to_csv('demo.csv', index=False)
print(pd.read_csv('demo.csv', nrows=2))
print(pd.read_csv('demo.csv', usecols=['name','salary']).head(2))

df.head(2).to_csv('out.csv', index=False)
print(open('out.csv').read())

print(df.head(3))
print(df.tail(2))

print(df.shape)
print("rows:", df.shape[0], "columns:", df.shape[1])

df.info()

print(df.describe())

print(list(df.columns))
print(df.dtypes)

print(df[['exp','salary']].values)

print(df.sample(2, random_state=1))

print(df['name'])

print(df[['name', 'salary']])

print(df.loc[0])
print(df.loc[0:2, ['name','salary']])

print(df.iloc[0])
print(df.iloc[0:3, 0:2])
print(df.iloc[-1])

print(df.loc[0:2, 'name'])     # 3 rows - end included
print(df.iloc[0:2, 0])         # 2 rows - end excluded

print(df.at[0, 'name'])
print(df.iat[0, 0])

print(df[df['salary'] > 80000])

print(df[(df['dept'] == 'Tech') & (df['salary'] > 60000)])
print(df[(df['dept'] == 'HR') | (df['exp'] > 9)])

print(df[df['city'].isin(['Chennai', 'Pune'])])

print(df[df['salary'].between(60000, 90000)])

print(df[df['name'].str.contains('a')])

print(df.query('salary > 80000 and dept == "Sales"'))

print(df[~(df['dept'] == 'Tech')])

print(df['age'].isnull())
print(df.isnull().sum())      # count per column

print(df.shape)
print(df.dropna().shape)
print(df.dropna(subset=['age']).shape)

print(df['age'].fillna(0).tolist())
print(df['age'].fillna(df['age'].mean()).round(1).tolist())

print(df['age'].fillna(df['age'].median()).tolist())

d = pd.DataFrame({'a':[1,2,2,3],'b':['x','y','y','z']})
print(d.duplicated())
print(d.duplicated().sum())

d = pd.DataFrame({'a':[1,2,2,3]})
print(d.drop_duplicates())
print(df.drop_duplicates(subset=['dept']))

d = df.copy()
d['bonus'] = d['salary'] * 0.10
print(d[['name','salary','bonus']].head(3))

d = df.rename(columns={'exp': 'experience', 'dept': 'department'})
print(list(d.columns))

print(df.drop(columns=['city','rating']).head(2))
print(df.drop(index=[0,1]).shape)

d = df.dropna(subset=['age']).copy()
d['age'] = d['age'].astype(int)
print(d['age'].tolist())

print(df['dept'].replace({'Tech':'Engineering'}).tolist())

print(df['salary'].apply(lambda x: x / 1000).tolist())

def band(s):
    return 'High' if s > 80000 else 'Low'
print(df['salary'].apply(band).tolist())

order = {'Poor':1, 'Average':2, 'Good':3, 'Excellent':4}
print(df['rating'].map(order).tolist())

bands = pd.cut(df['salary'], bins=[0,70000,100000,999999],
               labels=['Low','Medium','High'])
print(bands.tolist())

print(df.sort_values('salary')[['name','salary']])

print(df.sort_values('salary', ascending=False)[['name','salary']].head(3))

print(df.sort_values(['dept','salary'])[['dept','name','salary']])

print(df.nlargest(3, 'salary')[['name','salary']])
print(df.nsmallest(2, 'salary')[['name','salary']])

print(df.sort_values('salary').sort_index().head(3)[['name','salary']])

print(df['salary'].mean())
print(df['salary'].median())

print(df['dept'].mode()[0])
print(df['city'].mode().tolist())

print(round(df['salary'].std(), 2))
print(round(df['salary'].var(), 2))

print(df['salary'].min(), df['salary'].max())
print(df['salary'].sum())

print(df['age'].count())     # missing not counted
print(df['dept'].nunique())

print(df['dept'].value_counts())
print(df['dept'].value_counts(normalize=True).round(2))

print(df['city'].unique())

print(df['salary'].quantile(0.25))
print(df['salary'].quantile([0.25, 0.5, 0.75]).tolist())

print(round(df['exp'].corr(df['salary']), 3))
print(df[['exp','salary']].corr().round(3))

print(df['salary'].cumsum().tolist())

print(df.groupby('dept')['salary'].mean())

print(df.groupby('dept').size())
print(df.groupby('dept')['salary'].count())

print(df.groupby('dept')['salary'].agg(['count','mean','max']))

print(df.groupby('dept').agg({'salary':'mean', 'exp':'max'}))

print(df.groupby(['dept','city'])['salary'].mean())

g = df.groupby('dept')['salary'].mean().reset_index()
print(g)

print(pd.pivot_table(df, values='salary', index='dept',
                     columns='city', aggfunc='mean'))

print(pd.crosstab(df['dept'], df['city']))

w = pd.DataFrame({'name':['Rahul','Priya'],'maths':[87,92],'science':[78,85]})
print(pd.melt(w, id_vars='name', var_name='subject', value_name='marks'))

d = df.set_index('name')
print(d.loc['Rahul'])
print(d.reset_index().head(2)[['name','dept']])

a = df.head(2)[['name','dept']]
b = df.tail(2)[['name','dept']]
print(pd.concat([a, b]))

a = df[['name']].head(3)
b = df[['salary']].head(3)
print(pd.concat([a, b], axis=1))

emp  = pd.DataFrame({'name':['Rahul','Priya'], 'dept_id':[1, 2]})
dept = pd.DataFrame({'dept_id':[1, 2], 'dept_name':['Tech','Sales']})
print(pd.merge(emp, dept, on='dept_id'))

a = pd.DataFrame({'id':[1,2,3], 'x':['a','b','c']})
b = pd.DataFrame({'id':[2,3,4], 'y':['B','C','D']})
print(pd.merge(a, b, on='id', how='inner'))
print(pd.merge(a, b, on='id', how='left'))

print(df['name'].str.upper().tolist())

print(df['name'].str.len().tolist())

messy = pd.Series(['  Rahul ', ' Priya'])
print(messy.str.strip().tolist())
print(df['dept'].str.replace('Tech', 'IT').tolist())

full = pd.Series(['Rahul Sharma', 'Priya Nair'])
print(full.str.split(' ').tolist())
print(full.str.split(' ').str[0].tolist())

d = pd.DataFrame({'joined':['2022-01-15','2023-06-30']})
d['joined'] = pd.to_datetime(d['joined'])
print(d.dtypes)
print(d)

d = pd.DataFrame({'joined': pd.to_datetime(['2022-01-15','2023-06-30'])})
print(d['joined'].dt.year.tolist())
print(d['joined'].dt.month.tolist())
print(d['joined'].dt.day_name().tolist())

d = pd.to_datetime(['2022-01-01','2024-01-01'])
print((d[1] - d[0]).days)

SELECT sql FROM sqlite_master WHERE name='employees';

SELECT emp_id, name FROM employees LIMIT 3;

SELECT e.name, d.dept_name FROM employees e JOIN departments d ON e.dept_id=d.dept_id LIMIT 3;

SELECT name, salary FROM employees LIMIT 3;

SELECT name, salary FROM employees WHERE salary > 70000;

SELECT name, salary FROM employees ORDER BY salary DESC LIMIT 3;

SELECT name, salary FROM employees ORDER BY salary DESC LIMIT 2;

SELECT DISTINCT dept_id FROM employees ORDER BY dept_id;

SELECT name AS employee, salary AS monthly_pay FROM employees LIMIT 2;

SELECT name, dept_id FROM employees WHERE dept_id IN (1,3);

SELECT name, salary FROM employees WHERE salary BETWEEN 60000 AND 90000;

SELECT name FROM employees WHERE name LIKE '%Kumar%';

SELECT name, rating FROM employees WHERE rating IS NULL;

SELECT COUNT(*) AS rows_now FROM employees;

SELECT name, salary FROM employees WHERE emp_id=101;

SELECT COUNT(*) AS total FROM employees;

SELECT name FROM pragma_table_info('employees') LIMIT 4;

SELECT UPPER(name) AS caps, LOWER(name) AS small FROM employees LIMIT 2;

SELECT name, LENGTH(name) AS chars FROM employees LIMIT 3;

SELECT name, SUBSTR(name,1,5) AS first_five FROM employees LIMIT 3;

SELECT name || ' works in dept ' || dept_id AS description FROM employees LIMIT 2;

SELECT '[' || TRIM('   Rahul   ') || ']' AS trimmed;

SELECT REPLACE(name,'Kumar','K.') AS shortened FROM employees WHERE name LIKE '%Kumar%';

SELECT name, STRFTIME('%Y',join_date) AS yr, STRFTIME('%m',join_date) AS mth FROM employees LIMIT 3;

SELECT DATE('2026-09-04') AS today;

SELECT name, 2026 - CAST(STRFTIME('%Y',join_date) AS INTEGER) AS years_here FROM employees LIMIT 3;

SELECT name, salary,
  CASE WHEN salary > 100000 THEN 'High'
       WHEN salary > 65000  THEN 'Medium'
       ELSE 'Low' END AS band
FROM employees ORDER BY salary DESC;

SELECT name, COALESCE(rating,'Not rated') AS rating FROM employees;

SELECT COUNT(*) AS all_rows, COUNT(rating) AS with_rating FROM employees;

SELECT SUM(salary) AS total, ROUND(AVG(salary),0) AS average FROM employees;

SELECT MIN(salary) AS lowest, MAX(salary) AS highest FROM employees;

SELECT dept_id, COUNT(*) AS headcount, ROUND(AVG(salary),0) AS avg_sal FROM employees GROUP BY dept_id;

SELECT dept_id, COUNT(*) AS n FROM employees GROUP BY dept_id HAVING COUNT(*) > 1;

SELECT name, salary FROM employees WHERE salary > (SELECT AVG(salary) FROM employees);

SELECT MAX(salary) AS second_highest FROM employees WHERE salary < (SELECT MAX(salary) FROM employees);

SELECT name FROM employees WHERE dept_id IN (SELECT dept_id FROM departments WHERE city='Bangalore');

SELECT e.name, d.dept_name FROM employees e INNER JOIN departments d ON e.dept_id=d.dept_id LIMIT 4;

SELECT d.dept_name, COUNT(e.emp_id) AS headcount FROM departments d LEFT JOIN employees e ON d.dept_id=e.dept_id GROUP BY d.dept_name;

SELECT d.dept_name FROM departments d LEFT JOIN employees e ON d.dept_id=e.dept_id WHERE e.emp_id IS NULL;

SELECT a.name, b.name AS same_dept_colleague FROM employees a JOIN employees b ON a.dept_id=b.dept_id AND a.emp_id<b.emp_id;

SELECT name FROM employees WHERE salary>100000 UNION SELECT name FROM employees WHERE experience>9;

SELECT name, salary, ROW_NUMBER() OVER (ORDER BY salary DESC) AS rn FROM employees LIMIT 4;

SELECT name, salary, RANK() OVER (ORDER BY salary DESC) AS rnk FROM employees LIMIT 4;

SELECT name, dept_id, salary, RANK() OVER (PARTITION BY dept_id ORDER BY salary DESC) AS rnk FROM employees;

SELECT name, dept_id, salary, ROUND(AVG(salary) OVER (PARTITION BY dept_id),0) AS dept_avg FROM employees;

SELECT name, salary FROM employees WHERE salary > 80000;

SELECT 'CALL get_dept_summary(1);' AS mysql_syntax;

SELECT 'CREATE TRIGGER log_change AFTER UPDATE ON employees ...' AS mysql_syntax;