ORM for cloud spanner
Project description
Google Cloud Spanner-ORM:
Spanner ORM is a simple and small ORM. It easy to learn and intuitive to use.
product:
name: Google Cloud Spanner ORM
short_name: spannerorm
url: https://github.com/leapfrogtechnology/spanner-orm.git
description:
spannerdb ORM is a highly scalable, efficient Google Cloud Spanner ORM.
Features
- A small, simple ORM
- Support Cloud Spanner Database
- python 2.7 - 3.6
- Connection pooling
- Support DB Transaction
- Support DB Migration
Table of contents
- Installation
- Connection
- BaseModel and DataType
- Query Records
- Block Records INSERT | UPDATE
- Save Record (ADD / UPDATE)
- Delete Records
- Running with Transaction
- Model object functions
- Model class functions
- SpannerDb
- Database Migration
Installation
- Install pip (If not install in your system)
sudo apt-get install python-pip
- Install client library
pip install --upgrade google-cloud-spanner
- Installing with Git
git clone https://github.com/leapfrogtechnology/spanner-orm.git
cd spanner-orm
python setup.py install
- Download
Service account json
- Go to the
GCP Console
>Service accounts
- Download key from service account list by clicking at
action
>create key
- Go to the
Connection
The spannerorm Connection object represents a connection to a database. The Connection class is instantiated with all the information needed to open a connection to a database, and then can be used.
from spannerorm import Connection instance_id = 'develop' database_id = 'auth' service_account_json = '/home/leapfrog/personal-data/python-work/opensource/spanner-orm/service_account.json' pool_size = 10 time_out = 5 ping_interval = 300 Connection.config(instance_id=instance_id, database_id=database_id, service_account_json=service_account_json, pool_size=pool_size, time_out=time_out, ping_interval=ping_interval)
Parameter | DataType | Required / Optional | Description |
---|---|---|---|
instance_id | String | Required | Cloud Spanner Instance Id |
database_id | String | Required | Cloud Spanner Database |
service_account_json | String | Required | Service account json's file full path |
pool_size | Integer | Optional | Max number of database pool connection |
time_out | Integer | Optional | In seconds, to wait for a returned session |
ping_interval | Integer | Optional | Interval at which to ping sessions |
BaseModel and DataType
BaseModel classes, DataType instances, BaseModel instances, Relation instances all map to database concepts:
Class \ Instance | Corresponds to… |
---|---|
BaseModel | Database table |
DataType instance | Column on a table |
BaseModel instance | Row in a database table |
Relation instance | Database relational |
DataType
The DataType
class is used to describe the mapping of Model attributes to database columns. Each field type has a
corresponding SQL storage class (i.e. varchar, int), and conversion between DataType and underlying storage is handled
transparently.
DataType | Corresponding Spanner Data Type |
---|---|
StringField | STRING |
IntegerField | INT64 |
FloatField | FLOAT64 |
BoolField | BOOL |
BytesField | BYTES |
TimeStampField | TIMESTAMP |
DateField | DATE |
EnumField | STRING |
DataType Field arguments
- StringField arguments
Arguments | Require / Optional | Type | Description |
---|---|---|---|
db_column | Required | str | Corresponding db column |
null | False | bool | is allow null value, Default True |
default | False | str | Default value |
max_length | False | int | Max allow string length |
reg_exr | False | str | Regex expression |
eg:
from spannerorm import StringField _email = StringField(db_column='email', null=False, reg_exr='^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$')
- IntegerField arguments
Arguments | Require / Optional | Type | Description |
---|---|---|---|
db_column | Required | str | Corresponding db column |
null | Optional | bool | is allow null value, Default True |
default | Optional | int | Default value |
min_value | Optional | int | Max allow value |
max_value | Optional | int | Min allow value |
- FloatField arguments
Arguments | Require / Optional | Type | Description |
---|---|---|---|
db_column | Required | str | Corresponding db column |
null | Optional | bool | is allow null value, Default True |
default | Optional | float | Default value |
min_value | Optional | float | Max allow string length |
max_value | Optional | float | Regex expression |
decimal_places | Optional | int | Regex expression |
- BoolField arguments
Arguments | Require / Optional | Type | Description |
---|---|---|---|
db_column | Required | str | Corresponding db column |
null | Optional | bool | is allow null value, Default True |
default | Optional | bool | Default value |
- BytesField arguments
Arguments | Require / Optional | Type | Description |
---|---|---|---|
db_column | Required | str | Corresponding db column |
null | Optional | bool | is allow null value, Default True |
default | Optional | str | Default value |
- TimeStampField arguments
Arguments | Require / Optional | Type | Description |
---|---|---|---|
db_column | Required | str | Corresponding db column |
null | Optional | bool | is allow null value, Default True |
default | Optional | float | Default value |
- DateField arguments
Arguments | Require / Optional | Type | Description |
---|---|---|---|
db_column | Required | str | Corresponding db column |
null | Optional | bool | is allow null value, Default True |
default | Optional | datetime.date | Default value |
- EnumField arguments
Arguments | Require / Optional | Type | Description |
---|---|---|---|
db_column | Required | str | Corresponding db column |
null | Optional | bool | is allow null value, Default True |
default | Optional | str | Default value |
enum_list | Require | list | Enum values |
- Simple Example
from time import time from uuid import uuid4 from spannerorm import BaseModel, IntegerField, StringField, BoolField, TimeStampField, DateField class Sample(BaseModel): # Db Fields _id = StringField(db_column='id', null=False) _name = StringField(db_column='name', null=False, reg_exr='^[A-Z][ a-z]+') _modified_at = TimeStampField(db_column='modified_at', null=True, default=time()) @property @StringField.get def id(self): return self._id @id.setter @StringField.set def id(self, id): self._id = id @property @StringField.get def name(self): return self._name @name.setter @StringField.set def name(self, name): self._name = name @property @TimeStampField.get def modified_at(self): return self._modified_at @modified_at.setter @TimeStampField.set def modified_at(self, created): self._modified_at = created class Meta: db_table = 'sample' primary_key = 'id' @classmethod def generate_pk(cls): return uuid4()
Relation
Relation class is a special field type that allows one model to reference another.
RelationType | Description |
---|---|
OneToOne | OneToOne relation with reference model |
ManyToOne | ManyToOne relation with reference model |
OneToMany | OneToMany relation with reference model |
ManyToMany | ManyToMany relation with reference model |
- RelationType arguments
Arguments | Require / Optional | Type | Description |
---|---|---|---|
join_on | Required | str | Corresponding db column |
relation_name | Required | bool | is allow null value, Default True |
refer_to | Required | str | Default value |
-
Simple Example :
- User Model
import hashlib import role from time import time from uuid import uuid4 from spannerorm import BaseModel, StringField, BoolField, TimeStampField, ManyToOne class User(BaseModel): # Db column Fields _id = StringField(db_column='id', null=False) _name = StringField(db_column='name', null=False) _role_id = StringField(db_column='role_id', null=False) _created_at = TimeStampField(db_column='created_at', null=False, default=time()) # Relational Fields _role = ManyToOne(join_on='role_id', relation_name='role', refer_to='id') @property @StringField.get def id(self): return self._id @id.setter @StringField.set def id(self, id): self._id = id @property @StringField.get def name(self): return self._name @name.setter @StringField.set def name(self, name): self._name = name @property @StringField.get def role_id(self): return self._role_id @role_id.setter @StringField.set def role_id(self, role_id): self._role_id = role_id @property @TimeStampField.get def created_at(self): return self._created_at @created_at.setter @TimeStampField.set def created_at(self, created_at): self._created_at = created_at @property @ManyToOne.get def role(self): return self._role @role.setter @ManyToOne.set def role(self, data): self._role = data class Meta: db_table = 'users' primary_key = 'id' @classmethod def relations(cls): return { 'role': role.Role } @classmethod def generate_pk(cls): return uuid4()
Note: Model Field
& Relation Field
name should be _[prop_name]
form & should have property with getter
& setter
Meta
Model-specific configuration is placed in a special class called Meta
. Meta Class created inside model class.
# This Meta class placed inside mode class class Meta: db_table = 'users' primary_key = 'id' @classmethod def relations(cls): return { 'role': role.Role } @classmethod def generate_pk(cls): return uuid4()
- db_table: database table map to model
- primary_key: primary key of db table
- relations(cls): function return relations that reference to another model.
- generate_pk(cls): function that generate & return primary key value
Model Decorator
- spannerorm decorators
Decorator | Description |
---|---|
@StringField.get | StringField getter, should use with property decorator |
@StringField.set | StringField setter, should use with setter decorator |
@IntegerField.get | IntegerField getter, should use with property decorator |
@IntegerField.set | IntegerField setter, should use with setter decorator |
@FloatField.get | FloatField getter, should use with property decorator |
@FloatField.set | FloatField setter, should use with setter decorator |
@BoolField.get | BoolField getter, should use with property decorator |
@BoolField.set | BoolField setter, should use with setter decorator |
@BytesField.get | BytesField getter, should use with property decorator |
@BytesField.set | BytesField setter, should use with setter decorator |
@TimeStampField.get | TimeStampField getter, should use with property decorator |
@TimeStampField.set | TimeStampField setter, should use with setter decorator |
@DateField.get | DateField getter, should use with property decorator |
@DateField.set | DateField setter, should use with setter decorator |
@EnumField.get | EnumField getter, should use with property decorator |
@EnumField.set | EnumField setter, should use with setter decorator |
@OneToOne.get | OneToOne relation getter, should use with property decorator |
@OneToOne.set | OneToOne relation setter, should use with setter decorator |
@OneToMany.get | OneToMany relation getter, should use with property decorator |
@OneToMany.set | OneToMany relation setter, should use with setter decorator |
@ManyToOne.get | ManyToOne relation getter, should use with property decorator |
@ManyToOne.set | ManyToOne relation setter, should use with setter decorator |
@ManyToMany.get | ManyToMany relation getter, should use with property decorator |
@ManyToMany.set | ManyToMany relation setter, should use with setter decorator |
Query Records
Model query records public methods
count(criteria, transaction)
Count record filter by criteria
- params: - criteria: - Filter criteria - Type: Criteria - Default Value: None - Optional - transaction - DB transaction - Type: Transaction - Default value: None - Optional - return: - Count of record - Type: bool
eg: With out join
criteria = Criteria() criteria.condition([(User.role_id, '=', '1'), (User.organization_id, '=', '4707145032222247178')]) user = User.count(criteria)
find(criteria, transaction)
Fetch single record data filter by criteria
- params: - criteria: - Filter criteria - Type: Criteria - Default Value: None - Optional - transaction - DB transaction - Type: Transaction - Default value: None - Optional - return: - If exist return Model object else None - Type: Model object | None
eg: With out join
criteria = Criteria() criteria.condition([(User.role_id, '=', '1'), (User.organization_id, '=', '4707145032222247178')]) user = User.find(criteria)
eg: With join
criteria = Criteria() criteria.join_with(User.role) user = User.find() user_role = user.role
find_by_pk(pk, criteria, transaction)
Fetch record by primary key filter by criteria
- params: - pk: - Primary Key value - Type: str | int (depending on primary key data type) - Required - criteria: - Filter criteria - Type: Criteria - Default Value: None - Optional - transaction - DB transaction - Type: Transaction - Default value: None - Optional - return: - If exist return Model object else None - Type: Model object | None
eg:
criteria = Criteria() criteria.add_condition((User.is_deleted, '=', False)) user = User.find_by_pk('-300113230644022007', criteria)
find_all(criteria, transaction)
Fetch records filter by criteria
- params: - criteria: - Filter criteria - Type: Criteria - Default Value: None - Optional - transaction - DB transaction - Type: Transaction - Default value: None - Optional - return: - list of model -Type: list
eg: With out join
criteria = Criteria() criteria.condition([(User.email, 'LIKE', '%@lftechnology.com')]) criteria.add_condition((User.role_id, 'IN', ['1', '2'])) criteria.add_condition((User.organization_id, 'NOT IN', ['4707145032222247178'])) criteria.set_order_by(User.email, 'ASC') criteria.limit = 2 users = User.find_all(criteria)
eg: With ManyToOne Join
criteria = Criteria() criteria.join_with(User.role) criteria.join_with(User.organization) criteria.condition([(User.email, 'LIKE', '%@lftechnology.com')]) criteria.set_order_by(User.email, 'ASC') criteria.limit = 2 users = User.find_all(criteria) for user in users: print(user.role)
eg: With OneToMany Join
criteria = Criteria() criteria.join_with(Role.users) criteria.add_condition((User.email, '=', 'mjsanish+admin@gmail.com')) criteria.set_order_by(User.email, order='DESC') role = Role.find(criteria) users = role.users for user in users: print(user)
Criteria
Criteria
object represents a query filter criteria, such as conditions, ordering by, limit/offset.
criteria.condition(conditions, operator)
Set criteria condition that filter result set
- params: - conditions: - List of conditions - Type: list - Required - operator: - Sql operator - Type: str - Default: AND - Allow values: [AND | OR] - Optional
eg: WHERE users.email LIKe '%@lftechnology.com'
criteria = Criteria() criteria.condition([(User.email, 'LIKE', '%@lftechnology.com')])
eg: WHERE users.email LIKe '%@lftechnology.com' OR users.role_id IN ('1', '2')
criteria = Criteria() criteria.condition([(User.email, 'LIKE', '%@lftechnology.com'), (User.role_id, 'IN', ['1', '2'])], 'OR')
eg: WHERE user.name LIKE '%lf%' AND (users.active=true OR users.is_deleted=false)
criteria = Criteria() criteria.condition([((User.name, 'LIKE', '%lf%'), 'AND', ((User.active, '=', True), 'OR', (User.is_deleted, '=', False)))])
eg: WHERE (((users.name LIKE '%lf%') AND (users.active=true OR users.is_deleted=false)) OR (users.user_name='mjsanish' AND users.password='pass')) OR (users.role_id IN (1, 3))
criteria = Criteria() criteria.condition([(((User.name, 'LIKE', '%lf%'), 'AND', ((User.active, '=', True), 'OR', (User.is_deleted, '=', False))), 'OR', ((User.user_name, '=', 'mjsanish'), 'AND', (User.password, '=', 'pass'))), (User.role_id, 'IN', [1, 3])], 'OR')
criteria.add_condition(condition, operator)
Add criteria condition that filter result set
- params: - condition: - Filter condition - Type: tuple - Required - operator: - Condition operator - Type: str - Default: AND - Allow values: [AND | OR] - Optional
eg: WHERE users.email LIKe '%@lftechnology.com'
criteria = Criteria() criteria.add_condition([(User.email, 'LIKE', '%@lftechnology.com')])
eg: WHERE users.email LIKe '%@lftechnology.com' OR users.role_id IN ('1', '2')
criteria = Criteria() criteria.condition([(User.email, 'LIKE', '%@lftechnology.com')]) criteria.add_condition((User.role_id, 'IN', ['1', '2']), 'OR')
eg:
eg: WHERE user.name LIKE '%lf%' AND (users.active=false OR users.is_deleted=true)
criteria = Criteria() criteria.add_condition((User.name, 'LIKE', '%lf%')) criteria.add_condition(((User.active, '=', False), 'OR', (User.is_deleted, '=', True)))
Criteria condition
Criteria condition
object provide filter cirteria.
- Type: tuple(3) - suntax: (model.property, [= | > | < | >= | <= | <> | IN | NOT IN], value) (condition, [AND | OR], condition)
Criteria Condition Operators
Operator | Description | Example |
---|---|---|
= | Equal | (User.name, '=', 'sanish') |
> | Greater Than | (User.points, '>', 100) |
< | Less Than | (User.points, '<', 2000) |
>= | Greater Than Or Equal | (User.points, '>=', 100) |
<= | Less Than Or Equal | (User.points, '<=', 1000) |
<> | Not Equal | (User.name, '<>', 'sanish') |
LIKE | Search for a pattern | (User.name, 'LIKE', '%sa%') |
IN | Search for In Multiple values |
(User.role_id, 'IN', ['1', '2']) |
NOT IN | Search for Not In Multiple values |
(Task.status, 'NOT IN', ['pending', 'under review']) |
AND | Join two condition with AND operator |
((User.name, 'LIKE', '%sa%') , 'AND', (User.is_deleted, '=', False)) |
OR | Join two condition with OR operator |
((User.name, 'LIKE', '%sa%') , 'OR', (User.is_deleted, '=', False)) |
IS | Is null | (User.name, 'IS', 'NULL') |
IS NOT | Is not null | (User.name, 'IS NOT', 'NULL') |
criteria.limit
Setter limit criteria
- Type: int
criteria.offset
Setter offset criteria
- Type: int
eg: WHERE users.name LIKE '%lf%' LIMIT 5 OFFSET 10
criteria = Criteria() criteria.add_condition((User.name, 'LIKE', '%lf%')) criteria.limit = 5 criteria.offset = 10
criteria.set_order_by(order_by_props, order)
Set order by criteria
- params: - order_by_props: - Order by property or list of order by properties - Type: property | list - Require - order: - Define order on asc or desc - Type: str - Default: ASC - Optional - Allow values: [ASC | DESC]
eg: WHERE users.name LIKE '%lf%' ORDER BY users.name DESC
criteria = Criteria() criteria.add_condition((User.name, 'LIKE', '%lf%')) criteria.set_order_by(User.name, 'DESC')
eg: ORDER BY users.name, user.email ASC
criteria = Criteria() criteria.set_order_by([User.name, User.email])
criteria.oin_with(relation, join_type, join_condition)
- Add join with criteria. For joining should define relation in model
- params: - relation: - Model relation property - Type: property - Require - join_type: - Define join type - Type: str - Default value: 'LEFT' - Optional - Allow values: [LEFT, RIGHT, FULL] - join_condition: - Define join condition - Type: tuple - Optional
eg: LEFT JOIN users on roles.id=users.role_id WHERE roles.name='admin' AND users.email='mjsanish+admin@gmail.com'
criteria = Criteria() criteria.join_with(Role.users, join_condition=(User.is_deleted, '=', False)) criteria.add_condition((Role.name, '=', 'admin')) criteria.add_condition((User.email, '=', 'mjsanish+admin@gmail.com'))
Block Records INSERT | UPDATE
Model Block function allow insert/update lots of data quickly.
insert_block(raw_data_list, transaction)
Insert block of data
- params: - raw_data_list: - List of data - Type: list of dict - Require - transaction - DB transaction - Type: Transaction - Default value: None - Optional
eg:
data_list = [{ 'email': 'mjsanish+1@gmail.com', 'name': 'sanish1', "is_deleted": False, 'organization_id' : '4707145032222247178', 'role_id': '1', 'created_by': '-1202895510759970011', }, { 'email': 'mjsanish+2@gmail.com', 'name': 'sanish2', "is_deleted": False, 'organization_id' : '4707145032222247178', 'role_id': '1', 'created_by': '-1202895510759970011', }] users = User.insert_block(data_list)
update_block(cls, raw_data_list, transaction)
Update block of data
- params: - raw_data_list: - List of data - Type: list of dict - Require - transaction - DB transaction - Type: Transaction - Default value: None - Optional
eg:
data_list = [{ 'id': '271fc766-6de7-44c7-bd1c-b04954cd401f', 'email': 'mjsanish+100@gmail.com', 'name': 'sanish100' }, { 'id': '20b2e97f-4c77-460b-9324-bb7530d6b8f7', 'role_id': '2' }] users = User.update_block(data_list)
Save Record (ADD / UPDATE)
Model function provide ability to save model object.
save(model_obj, transaction)
Add/Update model data to database
- params: - model_obj: - Model object - Type: Model - Require - transaction - DB transaction - Type: Transaction - Default value: None - Optional - return: - Saved or updated model - Type: Model
eg:
user = User() user.name = 'some one' user.email = 'someone@gmail.com' user.organization_id = '4707145032222247178' user.role_id = '1' user = User.save(user)
save_all(model_obj_list, transaction)
Add / Update list of model to database
- params: - model_obj_list: - list of model objects - Type: list - Require - transaction - DB transaction - Type: Transaction - Default value: None - Optional - return: - list of model
eg:
user = User.find_by_pk('d3fefb2a-ef30-4c39-a560-81b459f5024e') user.name = 'some one' user.email = 'someone@gmail.com' user.organization_id = '4707145032222247178' user.role_id = '1' users = [] users.append(user) user = User.save_all(users)
update_by_pk(pk, data, transaction)
Update by primary key of model to database
- params: - pk: - primary key value - Type: int | str (base on primary key type) - Require - data: - Data to update - Type: dict - Require - transaction - DB transaction - Type: Transaction - Default value: None - Optional - return: - model
Delete Records
Model delete function allow delete records from database
delete_one(criteria, transaction)
Delete single record that match with criteria
- params: - criteria: - Filter criteria - Type: Criteria - Default Value: None - Optional - transaction - DB transaction - Type: Transaction - Default value: None - Optional - return: True on success else throw exception
delete_by_pk(pk, transaction)
Delete record by primary key
- params: - pk: - Primary key value - Type: int | str (base on primary key type) - Require - transaction - DB transaction - Type: Transaction - Default value: None - Optional - return: True on success else throw exception
delete_all(criteria, transaction)
Delete all records that match with criteria
- params: - criteria: - Filter criteria - Type: Criteria - Default Value: None - Optional - transaction - DB transaction - Type: Transaction - Default value: None - Optional - return: True on success else throw exception
Running with Transaction
Spanner-ORM provide @transactional decoration to support transaction eg:
@transactional def with_transaction(transaction): """ :type transaction: Transaction :param transaction: provide automatically by @transactional """ role = Role() role.name = 'guest' role.save(role, transaction) user = User() user.name = 'person 10' user.email = 'transaction@gmail.com' user.role_id = role.id user = User.save(user, transaction)
Model object functions
Spanner-ORM provide some basic model instance functions
set_props(raw_data):
Set model properties
- params: - raw_data - Model properties values in prop-value pairs - Type : dict - Required
eg:
user = User() user.set_props({ 'name' : 'Sanish', 'address' : 'Nepal' })
equals(obj)
Compare two model object is equals or not
- params: obj: - Model object that need to compare - Type : Model - Required - return: - True if both are same Model instance with equals values else return return False - Type: bool
is_new_record()
Check is new record model instance or existing record model instance
- return: - Is new record or not - Type: bool
get_pk_value()
- return: - primary key value - Type: int | str base on primary key data type
get_errors()
- return: - Model instance validation errors - Type: dict
eg:
user = User() user.email = 'someone@gmail.com' user.role_id = '1' if not user.validate(): errors = user.get_errors()
validate()
- return: - Check model instance data valid or not - Type: bool
eg:
user = User() user.email = 'someone@gmail.com' user.role_id = '1' if not user.validate(): errors = user.get_errors()
validate_property(prop)
- return: - Check model instance property data is valid or not - Type: dict {'is_valid':bool, 'error_msg':str}
Model class functions
Spanner-ORM provide some basic Model class functions
get_meta_data()
- return: - Return model mata data information - Type: dict
primary_key_property()
- return: - Primary key name - Type: str
has_property(property_name)
- return: - Check model has property by name, if exist return True else False - Type: bool
SpannerDb
SpannerDb
class provide some direct methods to run native and direct db operations.
SpannerDb.execute_query(query_string, params, transaction)
Execute query string
- params: - query_string: - Sql select query string - Type: str - Required - params: - Sql params - Type: dict - transaction - DB transaction - Type: Transaction - Default value: None - Optional - return: - Result set - Type dict
eg:
query_string = 'SELECT * FROM users WHERE name=@name' results = SpannerDb.execute_query(query_string, {'name': 'sanish'})
SpannerDb.execute_ddl_query(ddl_query_string)
Execute DDL query string
- params: - query_string: - DDL query string - Type: str - Required
eg:
query_string = ''' CREATE TABLE sample ( id STRING(64) NOT NULL, address STRING(MAX), is_active BOOL NOT NULL, join_date DATE, modified_at TIMESTAMP, name STRING(100) NOT NULL, points INT64 NOT NULL, ) PRIMARY KEY (id) ''' SpannerDb.execute_ddl_query(query_string)
SpannerDb.insert_data(table_name, columns, data)
Insert given table data
- params: - table_name: - Db table name - Type: str - Required - columns: - list of columns in which date inserting - Type: list - Required - eg. ['id', 'name'] - data: - List of data - Type: list - Required - eg. [(value11, value12), (value21, value22)]
SpannerDb.update_data(table_name, columns, data)
Update given table data
- params: - table_name: - Db table name - Type: str - Required - columns: - list of columns in which date updating - Type: list - Required - eg. ['id', 'name'] - data: - List of data - Type: list - Required - eg. [(value11, value12), (value21, value22)]
SpannerDb.save_data(table_name, columns, data)
Save given table data
- params: - table_name: - Db table name - Type: str - Required - columns: - list of columns in which date saving - Type: list - Required - eg. ['id', 'name'] - data: - List of data - Type: list - Required - eg. [(value11, value12), (value21, value22)]
SpannerDb.delete_data(table_name, id_list):
Delete given ids data row
- params: - table_name: - Db table name - Type: str - Required - id_list: - id tuple list - Type: type - eg. [('1',), ('2',)]
Database Migration
DbMigration
class responsible to run Db migration
setup Db Migration
- create migration.py file
- Add following code
from spannerorm import DbMigration class Migration(DbMigration): instance_id = '' database_id = '' service_account_json = '' if __name__ == '__main__': Migration.run()
- Config db connection
instance_id: Spanner database instance id database_id: Database name service_account_json: service account json location full path
Db Migration commands:
Available Migration Commands:
help : list available migration commands create [migration_name] : Create new migration file up : Run all new migrations down : Revert back last migration down <int> : Revert back last given number of migrations
eg: python migration.py create user_table
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
Built Distribution
Hashes for spannerorm-0.1.17-py2-none-any.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 51ca27baa83dd93b444e5cde4325343f2d53c176c6366e23ba934230c61f6de5 |
|
MD5 | f2a5d00453d98261fd281096a589d3cd |
|
BLAKE2-256 | add473739f2e8be54fe15ba2d379db272bd21267859917f852a522ae3b3772af |