def test_get_engine(): class FakeApp(object): pass app1 = FakeApp() app2 = FakeApp() db = SQLAlchemy(URI1, app=app1) assert SQLAlchemy().get_engine(app1) == db.engine assert SQLAlchemy().get_engine(app2) is None
def test_jti_auto_tablename(): """Test Joined Table Inheritance with an autonatically asigned table name. """ db = SQLAlchemy('sqlite://') class JaPerson(db.Model): id = db.Column(db.Integer, primary_key=True) discriminator = db.Column('type', db.String(50)) __mapper_args__ = {'polymorphic_on': discriminator} class JaEngineer(JaPerson): __mapper_args__ = {'polymorphic_identity': 'engineer'} id = db.Column(db.Integer, db.ForeignKey(JaPerson.id), primary_key=True) primary_language = db.Column(db.String(50)) class JaTeacher(JaPerson): __tablename__ = 'jti_auto_teachers' __mapper_args__ = {'polymorphic_identity': 'teacher'} id = db.Column(db.Integer, db.ForeignKey(JaPerson.id), primary_key=True) primary_language = db.Column(db.String(50)) assert JaPerson.__tablename__ == 'ja_people' assert JaEngineer.__tablename__ == 'ja_engineers' assert JaTeacher.__tablename__ == 'jti_auto_teachers' db.session.expunge_all()
def test_acti_auto_tablename(): """Test Abstract Concrete Table Inheritance with an autonatically asigned table name. """ db = SQLAlchemy('sqlite://') class Employee(AbstractConcreteBase, db.Model): pass class Manager(Employee): __tablename__ = 'acti_auto_managers' employee_id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50)) manager_data = db.Column(db.String(40)) __mapper_args__ = { 'polymorphic_identity': 'manager', 'concrete': True } class AaEngineer(Employee): employee_id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50)) engineer_info = db.Column(db.String(40)) __mapper_args__ = { 'polymorphic_identity': 'engineer', 'concrete': True } assert Manager.__tablename__ == 'acti_auto_managers' assert AaEngineer.__tablename__ == 'aa_engineers' db.session.expunge_all()
def test_cti_auto_tablename(): """Test Concrete Table Inheritance with an autonatically asigned table name. """ db = SQLAlchemy('sqlite://') class Person(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50)) class Engineer(Person): __mapper_args__ = {'concrete': True} id = db.Column(db.Integer, primary_key=True) primary_language = db.Column(db.String(50)) name = db.Column(db.String(50)) class Teacher(Person): __tablename__ = 'cti_auto_teachers' __mapper_args__ = {'concrete': True} id = db.Column(db.Integer, primary_key=True) primary_language = db.Column(db.String(50)) name = db.Column(db.String(50)) assert Person.__tablename__ == 'people' assert Engineer.__tablename__ == 'engineers' assert Teacher.__tablename__ == 'cti_auto_teachers' db.session.expunge_all()
def test_sti_auto_tablename(): """Test Single Table Inheritance with an autonatically asigned table name. """ db = SQLAlchemy('sqlite://') class SaEmployee(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50)) manager_data = db.Column(db.String(50)) engineer_info = db.Column(db.String(50)) type = db.Column(db.String(20)) __mapper_args__ = { 'polymorphic_on': type, 'polymorphic_identity': 'employee' } class SaManager(SaEmployee): __mapper_args__ = { 'polymorphic_identity': 'manager' } class SaEngineer(SaEmployee): __mapper_args__ = { 'polymorphic_identity': 'engineer' } assert SaEmployee.__tablename__ == 'sa_employees' assert SaManager.__tablename__ == 'sa_employees' assert SaEngineer.__tablename__ == 'sa_employees' db.session.expunge_all()
def test_define_table(): db = SQLAlchemy(URI1) db.Table('foobar', db.Column('foo', db.UnicodeText), db.Column('bar', db.UnicodeText)) db.Table('fizzbuzz', db.metadata, db.Column('fizz', db.Integer), db.Column('buzz', db.Integer)) db.create_all()
def test_sti_custom_tablename(): """Test Single Table Inheritance with a custom table name. """ db = SQLAlchemy('sqlite://') class Employee(db.Model): __tablename__ = 'sti_custom_employee' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50)) manager_data = db.Column(db.String(50)) engineer_info = db.Column(db.String(50)) type = db.Column(db.String(20)) __mapper_args__ = { 'polymorphic_on': type, 'polymorphic_identity': 'employee' } class Manager(Employee): __mapper_args__ = { 'polymorphic_identity': 'manager' } class Engineer(Employee): __mapper_args__ = { 'polymorphic_identity': 'engineer' } assert Employee.__tablename__ == 'sti_custom_employee' assert Manager.__tablename__ == 'sti_custom_employee' assert Engineer.__tablename__ == 'sti_custom_employee' db.session.expunge_all()
def test_custom_poolclass(): class _CustomPool(pool.StaticPool): _do_return_conn = mock.MagicMock() db = SQLAlchemy(URI1, poolclass=_CustomPool) db.create_all() _CustomPool._do_return_conn.assert_called_once()
def test_multiple_databases(): db1 = SQLAlchemy(URI1) db2 = SQLAlchemy(URI2) ToDo1 = create_test_model(db1) ToDo2 = create_test_model(db2) db1.create_all() db2.create_all() db1.add(ToDo1('A', 'a')) db1.add(ToDo1('B', 'b')) db2.add(ToDo2('Q', 'q')) db1.add(ToDo1('C', 'c')) db1.commit() db2.commit() assert db1.query(ToDo1).count() == 3 assert db2.query(ToDo2).count() == 1
def test_init_app(): class FakeApp(object): pass app = FakeApp() db = SQLAlchemy(URI1, app) assert app.databases db.init_app(app) assert len(app.databases) == 1
def test_flask_hooks_0_9(): teardown_appcontext_spy = mock.Mock() class AppWithTearDownAppContext(object): def teardown_appcontext(self, f): teardown_appcontext_spy() app = AppWithTearDownAppContext() SQLAlchemy(URI1, app=app) assert teardown_appcontext_spy.call_count
def test_flask_hooks_0_8(): teardown_request_spy = mock.Mock() class AppWithTearDownRequest(object): def teardown_request(self, f): teardown_request_spy() app = AppWithTearDownRequest() SQLAlchemy(URI1, app=app) assert teardown_request_spy.call_count
def test_bottle_hooks(): hook_spy = mock.Mock() class App(object): def hook(self, name): def decorator(f): hook_spy() return decorator app = App() SQLAlchemy(URI1, app=app) assert hook_spy.call_count
def test_id_mixin(): db = SQLAlchemy(URI1) class IDMixin(object): id = db.Column(db.Integer, primary_key=True) class Model(db.Model, IDMixin): field = db.Column(db.String) db.create_all() assert Model.__tablename__ == 'models' assert hasattr(Model, 'id')
def test_flask_sqlalchemy_query(): db = SQLAlchemy(URI1) ToDo = create_test_model(db) db.create_all() db.add(ToDo('First', 'The text')) db.add(ToDo('Second', 'The text')) db.flush() titles = ' '.join(x.title for x in ToDo.query.all()) assert titles == 'First Second' data = ToDo.query.filter(ToDo.title == 'First').all() assert len(data) == 1
def test_custom_metaclass(): class _CustomMeta(_BoundDeclarativeMeta): def __init__(self, name, bases, dic): _BoundDeclarativeMeta.__init__(self, name, bases, dic) if hasattr(self, 'id'): setattr(self, 'test', 1) db = SQLAlchemy(URI1, metaclass=_CustomMeta) class Model(db.Model): id = db.Column(db.Integer, primary_key=True) db.create_all() assert Model.test == 1
def test_mixin_no_tablename(): """Test for a tablename defined in a mixin. """ db = SQLAlchemy('sqlite://') class BaseMixin(object): @declared_attr def id(cls): return db.Column(db.Integer, primary_key=True) class MEngineer(BaseMixin, db.Model): name = db.Column(db.String(50)) assert MEngineer.__tablename__ == 'm_engineers' db.session.expunge_all()
def test_flask_hooks_old(): after_request_spy = mock.Mock() on_exception_spy = mock.Mock() class App(object): def after_request(self, f): after_request_spy() def on_exception(self, f): on_exception_spy() app = App() SQLAlchemy(URI1, app=app) assert after_request_spy.call_count assert on_exception_spy.call_count
def test_model_helpers(): db = SQLAlchemy() class Row(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(60), nullable=False) created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) db.create_all() db.add(Row(name='a')) db.flush() row = db.query(Row).first() assert str(row) == '<Row>' assert dict(row)['name'] == 'a'
def test_aggregated_query(): db = SQLAlchemy(URI1) class Unit(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(60)) price = db.Column(db.Integer) db.create_all() db.add(Unit(price=25)) db.add(Unit(price=5)) db.add(Unit(price=10)) db.add(Unit(price=3)) db.commit() res = db.query(db.func.sum(Unit.price).label('price')).first() assert res.price == 43
def test_mixin_overwritten_tablename(): """Test for a tablename defined in a mixin but overwritten. """ db = SQLAlchemy('sqlite://') class EmployeeMixin(object): __tablename__ = 'mixin_tablename' @declared_attr def id(cls): return db.Column(db.Integer, primary_key=True) class Engineer(EmployeeMixin, db.Model): __tablename__ = 'mixin_overwritten_tablename' name = db.Column(db.String(50)) assert Engineer.__tablename__ == 'mixin_overwritten_tablename' db.session.expunge_all()
def test_reconfigure(tmpdir): db = SQLAlchemy(URI1, echo=False) class CustomQuery(BaseQuery): some_attr = 1 class Model(db.Model): id = db.Column(db.Integer, primary_key=True) db.create_all() db.add(Model()) db.commit() tmp_db_file = tmpdir.mkdir('test_reconfigure').join('db.sqlite') uri = 'sqlite:///%s' % tmp_db_file.strpath.replace('\\', '/') db.reconfigure(uri=uri, echo=True, query_cls=CustomQuery) assert not Model.__table__.exists(db.engine) assert (uri, True) == db.connector._connected_for assert isinstance(db.query(Model), CustomQuery) assert db.query(Model).some_attr == 1
def create_test_model(): db = SQLAlchemy('sqlite://') class Item(db.Model): id = db.Column(db.Integer, primary_key=True) class Part(db.Model): id = db.Column(db.Integer, primary_key=True) item_id = db.Column(db.Integer, db.ForeignKey(Item.id)) item = db.relationship('Item', backref='parts') db.create_all() for i in range(1, 26): item = Item() db.add(item) db.commit() item = db.query(Item).first() for j in range(1, 26): db.add(Part(item=item)) db.commit() return db, Item, Part
from sqlalchemy_wrapper import SQLAlchemy from .config import CONFIG db_words_80_percent = SQLAlchemy( uri='sqlite:///server/databases/words80percent.db?check_same_thread=False', echo=CONFIG.ECHO_SQL) class Level(db_words_80_percent.Model): # type: ignore num = db_words_80_percent.Column('level_num', db_words_80_percent.Integer, primary_key=True) title = db_words_80_percent.Column('level_title', db_words_80_percent.Unicode) class Verse(db_words_80_percent.Model): # type: ignore sura_num = db_words_80_percent.Column('sura_num', db_words_80_percent.Integer, primary_key=True) ayah_num = db_words_80_percent.Column('ayah_num', db_words_80_percent.Integer, primary_key=True) text = db_words_80_percent.Column('text', db_words_80_percent.Unicode) class Word(db_words_80_percent.Model): # type: ignore level_num = db_words_80_percent.Column( 'level_num', db_words_80_percent.Integer,
from sqlalchemy import Column, Integer, ForeignKey, String from sqlalchemy.orm import relationship from sqlalchemy_wrapper import SQLAlchemy db = SQLAlchemy('sqlite:///:memory:') class Parent(db.Model): __tablename__ = 'parent' id = db.Column(Integer, primary_key=True) name = db.Column(String(20)) class Child(db.Model): __tablename__ = "child" id = Column(Integer, primary_key=True) parent_id = Column(Integer, ForeignKey('parent.id')) child_attr = db.Column(String(20)) parent = relationship('Parent') db.create_all() p1 = Parent(name="Akshay") db.add(p1) c1 = Child(child_attr="Child1") c1.parent_id = p1.id db.add(c1)
from sqlalchemy_wrapper import SQLAlchemy from sa_types import EnumChoiceType config_name = 'coding_challenge_restful.settings.Config' config = Config('') config.from_object(config_name) s3_client = boto3.client( 's3', # Hard coded strings as credentials, not recommended. aws_access_key_id=config['AWS_ACCESS_KEY'], aws_secret_access_key=config['AWS_SECRET_KEY']) isolation_level = 'READ COMMITTED' db = SQLAlchemy(uri=config['DATABASE_URL'], isolation_level=isolation_level) migrate = Migrate(compare_type=True) # Create Models Model = db.Model # Models are defined here class SurrogatePK(object): __table_args__ = {'extend_existing': True} id = Column(Integer, autoincrement=True, primary_key=True) class HasTablename(object): @declared_attr def __tablename__(cls):
from sqlalchemy_wrapper import SQLAlchemy from .config import DATABASE_URI db: SQLAlchemy = SQLAlchemy(DATABASE_URI) from app import models # noqa
# -*- coding: utf-8 -*- import requests, requesocks, BeautifulSoup, re, time, random, subprocess, telnetlib from sqlalchemy_wrapper import SQLAlchemy from stem import Signal from stem.control import Controller db = SQLAlchemy('sqlite:///Test_new.db') class Product(db.Model): id = db.Column(db.Integer, primary_key=True) product_id = db.Column(db.String(20), unique=True) product_cat_id = db.Column(db.String(10), unique=False) product_name = db.Column(db.String(200), unique=False) product_picture = db.Column(db.String(200), unique=False) product_other_picture = db.Column(db.Text, unique=False) product_test_one_flag = db.Column(db.Integer, unique=False) product_price_r = db.Column(db.Integer, unique=False) product_price_u = db.Column(db.Integer, unique=False) product_discount = db.Column(db.String(20), unique=False) product_store_id = db.Column(db.String(20), unique=False) product_store_title = db.Column(db.String(20), unique=False) partner_url = db.Column(db.String(200), unique=False) orders_count = db.Column(db.Integer, unique=False) score = db.Column(db.Integer, unique=False) def __init__(self, product_id, product_cat_id, product_name, product_picture, product_other_picture, product_test_one_flag, product_price_r, product_price_u, product_discount, product_store_id, product_store_title, partner_url, orders_count, score):
from sqlalchemy_wrapper import SQLAlchemy from .config import CONFIG db_quran_arabic = SQLAlchemy( uri='sqlite:///server/databases/quran_arabic.db?check_same_thread=False', echo=CONFIG.ECHO_SQL) class QuranArabic(db_quran_arabic.Model): # type: ignore __tablename__ = 'verses' sura_num = db_quran_arabic.Column( 'sura', db_quran_arabic.Integer, primary_key=True) ayah_num = db_quran_arabic.Column( 'ayah', db_quran_arabic.Integer, primary_key=True) text = db_quran_arabic.Column('text', db_quran_arabic.Unicode) if __name__ == '__main__': print(db_quran_arabic.session.query(QuranArabic).count())
from sqlalchemy_wrapper import SQLAlchemy import datetime import time import telegram import logging import sys import re import difflib # Enable logging logging.basicConfig( format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO) logger = logging.getLogger(__name__) db = SQLAlchemy('sqlite:///User.db') class User(db.Model): id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.String(20), unique=True) user_name = db.Column(db.String(200), unique=True) user_auth = db.Column(db.Integer, unique=False) def __init__(self, user_id, user_name, user_auth): self.user_id = user_id self.user_name = user_name self.user_auth = user_auth def __repr__(self): return '<User %r, %r>' % (self.user_id, self.user_name)