def set_table(db_name):
print('>> Setting main database to %s' % db_name)
from sqlobject.sqlite import builder
try:
cnx = builder()(db_name)
Project._connection = cnx
NavRecord._connection = cnx
StockRecord._connection = cnx
Guarantor._connection = cnx
Adviser._connection = cnx
Posterior._connection = cnx
ProjectLedge._connection = cnx
StockLedge._connection = cnx
BranchLedge._connection = cnx
GuarantorLedge._connection = cnx
Project.createTable(ifNotExists=True)
NavRecord.createTable(ifNotExists=True)
StockRecord.createTable(ifNotExists=True)
Guarantor.createTable(ifNotExists=True)
Adviser.createTable(ifNotExists=True)
Posterior.createTable(ifNotExists=True)
ProjectLedge.createTable(ifNotExists=True)
StockLedge.createTable(ifNotExists=True)
GuarantorLedge.createTable(ifNotExists=True)
BranchLedge.createTable(ifNotExists=True)
except Exception as e:
print(' Error:%s' % e)
def GetModel(self):
from sqlobject.sqlite import builder
from sqlobject import sqlhub
SQLiteConnection = builder()
conn = SQLiteConnection("hexmodel_sqlobject.db", debug=False)
sqlhub.processConnection = conn
try:
model = Model.get(1)
# a_thing = Thing.get(1)
except:
print("Oops - possibly no database - creating one now...")
Model.dropTable(True)
Model.createTable()
Thing.dropTable(True)
Thing.createTable()
the_model = Model()
assert the_model == Model.get(1)
# ~ thing1 = Thing(info="mary", model=model)
# ~ thing2 = Thing(info="fred", model=model)
model = Model.get(1)
return model
def set_bk_table(db_name, new_table=True):
if new_table:
if os.path.exists(db_name):
try:
os.remove(db_name)
except Exception as e:
print(' %s' % e)
print('>> Cannot delete %s!' % db_name)
print('>> Using %s for data export' % db_name)
else:
print('>> Using %s to update main database' % db_name)
from sqlobject.sqlite import builder
try:
cnx_bk = builder()(db_name)
Project_bk._connection = cnx_bk
NavRecord_bk._connection = cnx_bk
StockRecord_bk._connection = cnx_bk
Guarantor_bk._connection = cnx_bk
Adviser_bk._connection = cnx_bk
Posterior_bk._connection = cnx_bk
Project_bk.createTable(ifNotExists=True)
NavRecord_bk.createTable(ifNotExists=True)
StockRecord_bk.createTable(ifNotExists=True)
Guarantor_bk.createTable(ifNotExists=True)
Adviser_bk.createTable(ifNotExists=True)
Posterior_bk.createTable(ifNotExists=True)
except Exception as e:
print(' Error:%s' % e)
def GetModel(self):
from sqlobject.sqlite import builder
from sqlobject import sqlhub
SQLiteConnection = builder()
conn = SQLiteConnection('hexmodel_sqlobject.db', debug=False)
sqlhub.processConnection = conn
try:
model = Model.get(1)
#a_thing = Thing.get(1)
except:
print "Oops - possibly no database - creating one now..."
Model.dropTable(True)
Model.createTable()
Thing.dropTable(True)
Thing.createTable()
the_model = Model()
assert the_model == Model.get(1)
#~ thing1 = Thing(info="mary", model=model)
#~ thing2 = Thing(info="fred", model=model)
model = Model.get(1)
return model
def __init__(self, db_path='C:/Program Files (x86)/Thunder Network/Thunder/Profiles/TaskDb.dat'):
self.conn = builder()(db_path)
self.P2spTask._connection = self.conn
self.TaskBase._connection = self.conn
self.P2spTask.createTable(ifNotExists=True)
self.TaskBase.createTable(ifNotExists=True)
current_id = self.TaskBase.select().max('TaskId')
self.task_id = (current_id + 10) if current_id is not None else 10
def __init__(
self,
db_path='C:/Program Files (x86)/Thunder Network/Thunder/Profiles/TaskDb.dat'
):
self.conn = builder()(db_path)
self.P2spTask._connection = self.conn
self.TaskBase._connection = self.conn
self.P2spTask.createTable(ifNotExists=True)
self.TaskBase.createTable(ifNotExists=True)
current_id = self.TaskBase.select().max('TaskId')
self.task_id = (current_id + 10) if current_id is not None else 10
def init():
if not os.path.exists(expanduser(args.basedir)):
l.info("Creating base dir %s"%args.basedir)
os.makedirs(expanduser(args.basedir))
subscriptions = expanduser(args.basedir) + os.sep + 'subscriptions'
if not os.path.exists(subscriptions):
l.info("Creating empty subscriptions file %s"%subscriptions)
open(subscriptions,'a').write("# Add your RSS/ATOM subscriptions here.\n\n")
SeenEntry._connection = sqlite.builder()(expanduser(args.basedir + os.sep + 'seen.sqlite'), debug=False)
SeenEntry.createTable(ifNotExists=True)
def setupConnection():
"""
Create connection to configured SQLite database file.
The file will be created if it does not exist yet.
:return: DB connection object, which should be added SQLObject table
classes so they can access the db.
"""
dbPath = AppConf().get("SQL", "dbPath")
return builder()(dbPath)
def init():
if not os.path.exists(expanduser(args.basedir)):
l.info("Creating base dir %s"%args.basedir)
os.makedirs(expanduser(args.basedir))
subscriptions = expanduser(args.basedir) + os.sep + 'subscriptions'
if not os.path.exists(subscriptions):
l.info("Creating empty subscriptions file %s"%subscriptions)
open(subscriptions,'a').write("# Add your RSS/ATOM subscriptions here.\n\n")
SeenEntry._connection = sqlite.builder()(expanduser(args.basedir + os.sep + 'seen.sqlite'), debug=False)
SeenEntry.createTable(ifNotExists=True)
def set_user_table(db_name):
User._connection = builder()(db_name)
User.createTable(ifNotExists=True)
#!/usr/bin/python
import os
from sqlobject import *
from sqlobject.sqlite import builder
from setup import *
conn = builder()(db_name)
class CoinOrder(SQLObject):
_connection = conn
order_id = StringCol(alternateID=True) #unique
symbol = StringCol()
create_date = StringCol()
type = StringCol()
price = FloatCol()
avg_price = FloatCol()
amount = FloatCol()
deal_amount = FloatCol()
status = StringCol()
timestamp = IntCol()
class Account(SQLObject):
_connection = conn
timestamp = IntCol()
date = StringCol()
coin = StringCol()
balance = FloatCol()
'''
Created on 19.11.2012
@author: florian
@funktion: Diese Klasse dient dazu, mit der SQLite-Datenbank "database/db2.db" zu connecten.
Bei der Persistierung eines Objekts in der Datenbank wird immer das hier angelegte "conn"-Objekt verwendet.
Hierfuer muss die Library "SQLObject" installiert sein (Terminal: sudo easy_install -U SQLObject) und in den
Eclipse-Libraries entsprechend hinzugefuegt werden.
'''
import sqlobject
from sqlobject.sqlite import builder
conn = builder()('../database/db2.db')
import sqlobject
from sqlobject.sqlite import builder
conn = builder()('cruduser.db')
from sqlobject.sqlite import builder from thuisbioscoop.config import DB_LOCATION conn = builder()(DB_LOCATION)
#-------------------------------------------------------------------------------
# Name: Connection
# Purpose:
#
# Author: Administrator
#
# Created: 15/06/2014
# Copyright: (c) Administrator 2014
# Licence: <your licence>
#-------------------------------------------------------------------------------
import sqlobject
from sqlobject.sqlite import builder
conn = builder()('sqlobject_demo.db')
##conn = builder()(user='******', passwd='dbpassword',
## host='localhost', db='sqlobject_demo')
def main():
pass
if __name__ == '__main__':
main()
class Thing(SQLObject):
info = StringCol(length=50)
model = ForeignKey('Model', default=None)
#def __init__(self, info):
# self.info = info
def __str__(self):
return "Thing: " + self.info
def AddInfo(self, msg):
self.info += " " + msg
if __name__ == "__main__":
from sqlobject.sqlite import builder; SQLiteConnection = builder()
conn = SQLiteConnection('hexpersistence_sqlobject.db', debug=False)
sqlhub.processConnection = conn
init = raw_input("Create from scratch? (y/n) ")
if init == 'y':
print "Recreating database..."
Model.dropTable(True)
Model.createTable()
Thing.dropTable(True)
Thing.createTable()
model = Model()
thing1 = Thing(info="mary", model=model)
thing2 = Thing(info="fred", model=model)
server = Server1(host='localhost', port=8081)
SIMPLE = False
if SIMPLE:
# Create Persistence
# Create Model - SIMPLE
from hexmodel_simple import Model
from hexpersistence import PersistenceMock2
persistence = PersistenceMock2()
model = Model(persistence)
else:
# Create Model - SQLOBJECT
from sqlobject.sqlite import builder
from sqlobject import sqlhub
SQLiteConnection = builder()
conn = SQLiteConnection('hexmodel_sqlobject.db', debug=False)
sqlhub.processConnection = conn
from hexmodel_sqlobject import Model, Thing
try:
model = Model.get(1)
thing = Thing.get(1)
except:
print "Oops - possible no database - creating..."
Model.dropTable(True)
Model.createTable()
Thing.dropTable(True)
Thing.createTable()
model = Model()
thing1 = Thing(info="mary", model=model)
# -*- coding: utf-8 -*-
"""
Setup connection to database.
Alternatively, see approach in docs:
http://sqlobject.org/SQLObject.html#declaring-a-connection
"""
from sqlobject.sqlite import builder
# todo: move to config file
DB_NAME = 'logger.db'
# Create connection to database to be shared by table classes.
conn = builder()(DB_NAME)
#!/usr/bin/env python
#
#Hello World server in Python
#Binds REP socket to tcp://*:5555
#Expects "Hello" from client, replies with "World"
#@author Ian Barber <ian(dot)barber(at)gmail(dot)com>
#
import sqlobject
from sqlobject.sqlite import builder
conn = builder()('sqlobject_demo.db')
class PhoneNumber(sqlobject.SQLObject):
_connection = conn
# number = sqlobject.StringCol(length=14, unique=True)
number = sqlobject.StringCol(length=14, unique=True)
owner = sqlobject.ForeignKey('Person')
lastCall = sqlobject.DateTimeCol(default=None)
class Person(sqlobject.SQLObject):
# _idName='fooID'
_connection = conn
name = sqlobject.StringCol(length=255)
#The SQLObject-defined name for the "owner" field of PhoneNumber
#is "owner_id" since it's a reference to another table's primary
#key.
# numbers = sqlobject.MultipleJoin('PhoneNumber', joinColumn='owner_id')
numbers = sqlobject.MultipleJoin('PhoneNumber')
print("path to prepImg.db: %s" % paths['img.db'])
except:
print('ERROR: load_settings')
paths = {'img.db':
'/media/valdecar/forData/data/projects/pythonDB/img.db',
'prepImg.db':
'/media/valdecar/forData/data/projects/pythonDB/prepImg.db'
}
return(paths)
paths = load_paths()
connection = sqlite.builder()(
# '/media/valdecar/forData/data/projects/pythonDB/img.db'
paths['img.db']
)
# create table
class imgDB(SQLObject):
# every tables must has a pointer to database
_connection = connection
imgName = StringCol()
imgOrign = StringCol()
imgLabel = IntCol()
imgDB.createTable(ifNotExists=True)
def init_db(data_dir):
Episode._connection = sqlite.builder()(
expanduser(data_dir + os.sep + "episodes.db"), debug=False
)
Episode.createTable(ifNotExists=True)
info = StringCol(length=50)
model = ForeignKey('Model', default=None)
#def __init__(self, info):
# self.info = info
def __str__(self):
return "Thing: " + self.info
def AddInfo(self, msg):
self.info += " " + msg
if __name__ == "__main__":
from sqlobject.sqlite import builder
SQLiteConnection = builder()
#conn = SQLiteConnection('hexpersistence_sqlobject.db', debug=False)
conn = SQLiteConnection('hexmodel_sqlobject.db', debug=False)
sqlhub.processConnection = conn
init = raw_input("Create from scratch? (y/n) ")
if init == 'y':
print "Recreating database..."
Model.dropTable(True)
Model.createTable()
Thing.dropTable(True)
Thing.createTable()
model = Model()
thing1 = Thing(info="mary", model=model)
# http://www.andypatterns.com/index.php/blog/object_relational_mapping_pattern_-_using_sqlobj/
# http://www.ibm.com/developerworks/opensource/library/os-pythonsqlo/
from sqlobject import *
from sqlobject.sqlite import builder; SQLiteConnection = builder()
conn = SQLiteConnection('andyormtest1.db', debug=False)
class Cubicle(SQLObject):
_connection = conn
location = StringCol(length=20, default="unknown")
occupant = ForeignKey('Person', default=None)
def SetOccupant(self, person):
# Evict any previous occupant
if self.occupant:
self.occupant.cubicle = None
self.occupant = person # New occupant wired in
person.cubicle = self # back pointer
class Person(SQLObject):
_connection = conn
firstname = StringCol(length=20)
lastname = StringCol(length=20)
cubicle = ForeignKey('Cubicle', default=None)
orders = MultipleJoin('GiftOrder')
addresses = RelatedJoin('Address')
def AddOrder(self, giftOrder):
#self.orders.append(giftOrder) # one to many # SQL OBJECT doesn't need this
giftOrder.person = self # back pointer ** becomes the primary info sqlobject goes on
