1:
```
from sqlalchemy import create_engine
import os
eng = create_engine("sqlite:///some.db")
eng.execute("""create table employee (emp_id integer primary key,emp_name varchar)""")
eng.execute("insert into employee (emp_id, emp_name) values (1,'dilbert')")
r = eng.execute("select * from employee")
print(r)
```

2:
```
from sqlalchemy import create_engine, MetaData, Table, Column
from sqlalchemy import String, Integer, DateTime, ForeignKey
from sqlalchemy import inspect

eng = create_engine("sqlite:///some.db")
metadata = MetaData()
net_table = Table('network', metadata,
                    Column('network_id', Integer, primary_key=True),
                    Column('name', String, nullable=False),
                    Column('created_at', DateTime, nullable=False),
                    Column('owner_id', Integer, ForeignKey('user.id'))
                    )
user_table = Table('user', metadata,
                   Column('id', Integer, primary_key=True),
                   Column('name', String),
                   Column('fullname', String)
                   )
metadata.create_all(eng)
metadata2 = MetaData()
reflected = Table('user', metadata2, autoload=True, autoload_with=eng)
inspector = inspect(eng)
inspector.get_columns('network')

for inspect_table in inspector.get_table_names():
    for inspect_column in inspector.get_columns(inspect_table):
        if inspect_column ['name'] == 'story_id':
            print (inspect_table)
```

3:
```
from sqlalchemy import create_engine
from sqlalchemy import MetaData
from sqlalchemy import Table, Column
from sqlalchemy import Integer, String, ForeignKey
from sqlalchemy import select, func
import os

metadata = MetaData()
engine = create_engine("sqlite:///some.db")

user_table = Table('user', metadata,
                   Column('id', Integer, primary_key=True),
                   Column('username', String(50)),
                   Column('fullname', String(50))
                   )

metadata.create_all(engine)

print(user_table.c.fullname == 'ed')
print((user_table.c.fullname == 'ed') & (user_table.c.id > 5))
print((user_table.c.username == 'edward') | ((user_table.c.fullname == 'ed') & (user_table.c.id > 5)))



insert = user_table.insert().values(username="dilbert", fullname="Dilbert Jones")
print(insert)

conn = engine.connect()
r = conn.execute(insert)
conn.close()

request=select([user_table.c.id, user_table.c.username, user_table.c.fullname]).\
    where((user_table.c.username == 'wendy')|(user_table.c.username == 'dilbert')).\
    order_by(user_table.c.fullname)

r=engine.execute(request)
print(r.fetchall())



address_table = Table("address", metadata,
                      Column('id', Integer, primary_key=True),
                      Column('user_id', Integer, ForeignKey('user.id'), nullable=False),
                      Column('email_address', String(100), nullable=False)
                      )
metadata.create_all(engine)

engine.execute(user_table.insert().values(username='ed', fullname='Ed Jones'))
engine.execute(address_table.insert().values(user_id='2', email_address='ed@ed.com'))

request=select([user_table.c.fullname, address_table.c.email_address]).select_from(user_table.join(address_table)).\
    where(user_table.c.username == 'ed').order_by(address_table.c.email_address)
r=engine.execute(request)
print(r.fetchall())

r=engine.execute(user_table.update().values(fullname="Ed Jones").where(user_table.c.username == "ed"))
print(r.rowcount)




address_sel = select([address_table.c.email_address]).\
    where(user_table.c.id == address_table.c.user_id)
print(address_sel)

r =select([user_table.c.username, address_sel.as_scalar().where(user_table.c.username.in_(['jack', 'wendy']))])
print(r)
print(engine.execute(r).fetchall())
```

4:
```
from sqlalchemy import create_engine
from sqlalchemy import MetaData
from sqlalchemy import Column, Integer, String, Numeric, func,ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import Session,relationship
import os

metadata = MetaData()
engine = create_engine("sqlite:///some.db")

Base = declarative_base()

class Network(Base):
    __tablename__ = 'network'

    network_id = Column(Integer, primary_key=True)
    name = Column(String(100), nullable=False)

    def __repr__(self):
        return "<User(%r, %r)>" % (self.name, self.fullname)

Base.metadata.create_all(engine)

session = Session(bind=engine)
session.add_all([
    Network(name='net1'),
    Network(name='net2')
])
session.commit()







class User(Base):
    __tablename__ = 'user'

    id = Column(Integer, primary_key=True)
    name = Column(String)
    fullname = Column(String)

    def __repr__(self):
        return "<User(%r, %r)>" % (self.name, self.fullname)

Base.metadata.create_all(engine)

session.add_all([
    User(name='wendy', fullname='Wendy Weathersmith'),
    User(name='mary', fullname='Mary Contrary'),
    User(name='fred', fullname='Fred Flinstone'),
    User(name='ed', fullname='Ed Jones')
])
session.commit()

query = session.query(User.fullname).order_by(User.fullname)
print(query.all())
query = query.filter(User.name.in_(['mary','ed']))
print(query.all())
print(query[1])

class Address(Base):
    __tablename__ = 'address'

    id = Column(Integer, primary_key=True)
    email_address = Column(String, nullable=False)
    user_id = Column(Integer, ForeignKey('user.id'))
    user = relationship("User", backref="addresses")

    def __repr__(self):
        return "<Address(%r)>" % self.email_address

Base.metadata.create_all(engine)

jack = User(name='jack', fullname='Jack Bean')
jack.addresses = [Address(email_address='jack@gmail.com'),
                  Address(email_address='j25@yahoo.com'),
                  Address(email_address='jack@hotmail.com')]
session.add(jack)
session.commit()





class Account(Base):
    __tablename__ = 'account'

    id = Column(Integer, primary_key=True)
    owner = Column(String(50), nullable=False)
    balance = Column(Numeric, default=0)

    def __repr__(self):
        return "<Account(%r, %r)>" % (self.owner, self.balance)

class Transaction(Base):
    __tablename__ = 'transaction'

    id = Column(Integer, primary_key=True)
    amount = Column(Numeric, default=0)
    account_id = Column(Integer, ForeignKey('account.id'))
    account = relationship("Account", backref="transactions")

    def __repr__(self):
        return "Transaction: %r" % (self.amount)

Base.metadata.create_all(engine)

a1=Account(owner = "Jack Jones", balance = 5000)
a2=Account(owner="Ed Rendell", balance=10000)
session.add_all([
    a1,
    a2,
    Transaction(amount=500, account=a1),
    Transaction(amount=4500, account=a1),
    Transaction(amount=6000, account=a2),
    Transaction(amount=4000, account=a2)])

session.commit()

for account in session.query(Account).all():
    print(account.owner)
    print(account.balance)
    sum = 0
    for at in account.transactions:
        sum += at.amount
    print(sum)





query = session.query(User.name, Address.email_address).join(Address).filter(Address.email_address=="j25@yahoo.com")
print(query)
print (query.all())

from sqlalchemy.orm import aliased

user_alias1 = aliased(User)
user_alias2 = aliased(User)

from sqlalchemy import select

query=engine.execute(select([user_alias1.name, user_alias2.name]).distinct().where(user_alias1.name < user_alias2.name))
print (query.fetchall())

session.close()
```