Create yourself a simple database with this package.
Project description
This is RTS_Simpledatabase
a litle module for Python to create your quickly setup your own databases.
For the "How to use" lets get some sample data:
fieldname | userid | displayname | balance | joined | note |
---|---|---|---|---|---|
example value | 9783836285131 | randomtimetv | 6.50 | 31.03.2024 | |
format | str | str | float | str | str |
state | unique | modular | modular | locked | loose |
Initate the database
from RTSDB import DB
Database = DB('users') #creates or reads the users.rtsdb
# does not overwrite headers if there are headers already present
# all 3 (fields, format, states) are required and have to have the same length (in this case 5 entries)
Database.setHeaders({
"fields": ["userid", "displayname", "balance", "joined", "note" ],
"format": ["str", "str" , "float" , "str" , "str" ],
"states": ["unique", "modular" , "modular", "locked", "loose"]
})
Create a record
Database.create({
"userid": "9783836285131",
"displayname": "randomtimetv",
"balance": 6.50,
"joined": "31.03.2024" # dd.mm.yyy
})
Note: As you can see the .create() does not set the "note" field, this is because of the state being "loose", more to that in the States and Formats section.
Read a record
# selectorFieldName is idealy a unique, locked or index field like in this case "userid"
# selectorFieldValue is the known full value of selectorFieldName in this case "9783836285131"
# specificFieldNameToRead can be specified to obtain the value of a single field of the specified record
# if no field is given it returns the full record
# Syntax: Database.read({<selectorFieldName>:<selectorFieldValue>, [field=specificFieldNameToRead]})
Database.read({"userid":"9783836285131"})
# Returns: {"userid": "9783836285131","displayname": "randomtimetv","balance": 6.50"joined": "31.03.2024"}
Database.read({"userid":"9783836285131"},"displayname")
# Returns: "randomtimetv"
Does not return errors.
Update a record
# selectorFieldName is idealy a unique, locked or index field like in this case "userid"
# selectorFieldValue is the known full value of selectorFieldName in this case "9783836285131"
# targetField is the field you want to update, let's say "balance" needs to be updated
# newValue is the, you might have guessed it, new Value you want to set, lets say: 19.0
# Syntax: Database.update({<selectorFieldName>:<selectorFieldValue>}, <targetField>, <newValue>)
Database.update({"userid": "9783836285131"}, "balance", 19.0)
If something went wrong, like you tried to set the wrong type, you get:
InvalidType: "balance" does not match typerule "float" in: {'balance': '19'}
More to this errors in States and Formats
Trying to update locked fields results in:
LockedField: "joined" can not be updated.
Search a record
# Note: find is best used if you have a UserInterface with a search field
# query can be the full value or just a section of the actual value
# fieldname is by default __any and searches ALL fields except __id if they atleast partialy contain query, specify to limit the search to a single field
# case_sensitiv is by default True
# allow_typo is by default False
# Returns a list of all matching records
# Syntax: Database.find(<query type:string>, [fieldname=<fieldName>], [case_sensitiv=<True|False>], [allow_typo=<True|False>])
Database.find("Random", fieldname="displayname")
# Returns: [] because "Random" is not contained in "displayname" ("random" would be contained)
Database.find("Random", fieldname="displayname", case_sensitive=False)
# Returns: [{"userid": "9783836285131","displayname": "randomtimetv","balance": 6.50,"joined": "31.03.2024"}]
# because this time case_sensitive is turned off
Does not throw errors.
Test if a record exists
# selectorFieldName is idealy a unique, locked or index field like in this case "userid"
# selectorFieldValue is the known full value of selectorFieldName in this case "9783836285131"
# Returns a boolean
# Syntax: Database.exists({<selectorFieldName>:<selectorFieldValue>})
Database.exists({"userid","9783836285131"})
# Returns: True
Does not throw errors.
Delete a record
# __id is the hidden and unique id of the record
# Syntax: Database.delete(<__id>)
Database.delete(1)
# Deletes the record with the __id 1
Database.delete(Database.read({"userid":"9783836285131"}, "__id"))
# Deletes the record
Does not throw errors.
States and Formats
The State of a field can have following values:
unique = field can be changed but must contain a unique value among all records, only applies to the same field
locked = field needs to be set in .create(), can not be changed afterwards
modular = field can be updatet wit out restrictions
index = locked and unique
loose = field can remain unset or undefined and is modular
All fieldtypes, except "loose", need to be set by their rules in .create() otherwise it will throw an error like
MissingField: "displayname" is missing in: {"userid": "9783836285131","balance": 6.50,"joined": "31.03.2024"}
There are a few suportet formats as of yet:
__any = ignores type notations, aka can have any type. Is not recommended
str, list, dict, bool, float, int = only accepts its propper type as value
nostr, nolist, nodict, nobool, nofloat, noint = accepts it's propper type or None as value
If there is a Type missmatch you get:
InvalidType: "userid" does not match typerule "str" in: {"userid":9783836285131,"displayname": "randomtimetv","balance": 6.50,"joined": "31.03.2024"}
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.