
Security News
Deno 2.2 Improves Dependency Management and Expands Node.js Compatibility
Deno 2.2 enhances Node.js compatibility, improves dependency management, adds OpenTelemetry support, and expands linting and task automation for developers.
abarorm is a lightweight and easy-to-use Object-Relational Mapping (ORM) library for SQLite and PostgreSQL databases in Python. It aims to provide a simple and intuitive interface for managing database models and interactions.
![]() | abarorm is a lightweight and easy-to-use Object-Relational Mapping (ORM) library for SQLite and PostgreSQL databases in Python. It provides a simple and intuitive interface for managing database models and interactions. |
---|
create_table()
calls.all()
method.filter
method now supports order_by
functionality for result ordering.__gte
and __lte
functionality in the filter section.__repr__
, count
, and to_dict
methods.first()
, last()
, exists()
, and paginate()
methods to the QuerySet class.PostgreSQL
Bugs and structure.delete
and contains
methods.bulk_create
for efficient batch insertions.You can install abarorm from PyPI using pip:
pip install abarorm
For PostgreSQL support, you need to install psycopg2-binary
:
pip install psycopg2-binary
For detailed documentation, examples, and advanced usage, please visit the official abarorm documentation website.
Before defining models, you need to set up your database configuration. This involves specifying connection parameters for the database you are using (SQLite and PostgreSQL). Here’s an example of how to configure the database:
# Database configuration
DATABASE_CONFIG = {
'sqlite': {
'db_name': 'example.db', # Name of the SQLite database file
},
'postgresql': {
'host': 'localhost',
'user': 'hoopad',
'password': 'db_password',
'database': 'example_db', # Ensure this matches everywhere
'port': 5432,
}
}
After setting up the database configuration, you can define your models. A model is a representation of a database table. Here’s how to create a model using abarorm:
from abarorm import SQLiteModel, PostgreSQLModel
from abarorm.fields.sqlite import CharField, DateTimeField, ForeignKey
from abarorm.fields import psql
# Define the Category model for SQLite
class Category(SQLiteModel):
class Meta:
db_config = DATABASE_CONFIG['sqlite']
table_name = 'categories' # Name of the table for storing the Category model data
title = CharField(max_length=200, null=False) # Title of the category, must be unique and not null
create_time = DateTimeField(auto_now=True, auto_now_add=True) # Automatically set to current datetime
update_time = DateTimeField(auto_now=True) # Automatically set to current datetime
# Define the Post model for Postgresql
class Post(PostgreSQLModel):
class Meta:
db_config = DATABASE_CONFIG['postgresql']
title = psql.CharField(max_length=100, null=False) # Title of the post, must be unique and not null
create_time = psql.DateTimeField(auto_now=True) # Automatically set to current datetime
category = psql.ForeignKey(to=Category) # Foreign key referring to the Category model
Now that you have defined your models, you can perform CRUD operations. Here’s a breakdown of each operation:
To create new records in the database, use the create()
method or Bulk Create: bulk_create
. For example:
# Create a new category
Category.create(title='Movies')
# Create a new post
category = Category.get(id=1) # Fetch the category with ID 1
if category:
Post.create(title='Godfather', category=category.id) # Create a new post associated with the fetched category
# Bulk Create Post
records = [
{"title": "Godfather Part II", "category": 1},
{"title": "Godfather Part III", "category": 1},
]
Post.bulk_create(records)
To read records from the database, use the all()
or get()
methods:
# Retrieve all posts
all_posts = Post.all()
# Retrieve a specific post by ID
post_data = Post.get(id=1)
The filter()
method allows you to retrieve records based on specified criteria. You can use keyword arguments to filter by field values and sort the results using order_by
.
# Filter posts by category ID and order by creation time
filtered_posts = Post.filter(category=category.id, order_by='-create_time')
You can also use special lookup expressions like __gte
(greater than or equal to) and __lte
(less than or equal to) for more complex queries:
# Retrieve posts created after a specific date
filtered_posts = Post.filter(create_time__gte='2024-01-01 00:00:00')
To update existing records, fetch the record, modify its attributes, and then save it:
if post_data:
post_data.title = "The Godfather"
post_data.save() # Save the updated post data
Or:
Post.update(1, title='Updated Godfather') # Update the title of the post with ID 1 to 'Updated Godfather'
To delete a record from the database, use the delete()
method:
Post.delete(id=1) # Delete the post with ID 1
# or Removal based on a sometimes repeated argument
Post.delete(title='Godfather')
This section covers how to convert records to dictionaries, count records, and use various query methods like first()
, last()
, exists()
, order_by()
, paginate()
, and contains()
. These methods are essential for data manipulation, debugging, and optimizing query performance.
to_dict()
MethodThe to_dict()
method converts a model instance (or a collection of instances) into a dictionary, which is particularly useful for data manipulation and serialization. It makes it easier to work with the data in Python or send it over an API.
# Retrieve all posts
posts = Post.all()
# Convert the collection of posts to a list of dictionaries
posts_dict = posts.to_dict()
print(posts_dict)
# Output: [{'id': 1, 'title': 'Godfather', 'create_time': '2024-01-01 12:00:00', ...}, {...}]
count
MethodThe count()
method returns the number of records that match the query. It’s an efficient way to find the size of a dataset without retrieving the actual data.
Example:
# Count the number of posts in the database
num_posts = Post.count()
print(num_posts) # Output: 10 (if there are 10 posts in the database)
The count()
method can also be used after applying filters to count specific records:
# Count the number of posts with a specific title
num_posts_with_title = Post.filter(title='Godfather').count()
print(num_posts_with_title) # Output: 3 (if there are 3 posts with the title 'Godfather')
first()
, last()
, exists()
, order_by()
, paginate()
and contains()
first()
: Returns the first result or None
if no results are present.last()
: Returns the last result or None
if no results are present.exists()
: Checks if any records exist in the QuerySet
.paginate()
: Handles pagination of results, allowing you to retrieve subsets of data based on page and page size.contains()
: Performs a case-insensitive search to check if a field contains a specific substring.Example:
# Check if any posts exist
exists = Post.all().exists()
# Get the first post
first_post = Post.all().first()
# Get the last post
last_post = Post.all().last()
# Paginate the results
paginated_posts = Post.all().paginate(1, 5) # Page 1, 5 results per page
# Using multiple querysets in one query
posts = Post.all().contains(title='god').order_by('create_time').paginate(1, 4).to_dict()
These methods are particularly useful for data manipulation and debugging, as they provide a simple way to view and interact with your database records.
Contributions are welcome! If you find any issues or have suggestions for improvements, please open an issue or submit a pull request on GitHub.
This project is licensed under the Apache-2.0 License - see the LICENSE file for details.
FAQs
abarorm is a lightweight and easy-to-use Object-Relational Mapping (ORM) library for SQLite and PostgreSQL databases in Python. It aims to provide a simple and intuitive interface for managing database models and interactions.
We found that abarorm demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Deno 2.2 enhances Node.js compatibility, improves dependency management, adds OpenTelemetry support, and expands linting and task automation for developers.
Security News
React's CRA deprecation announcement sparked community criticism over framework recommendations, leading to quick updates acknowledging build tools like Vite as valid alternatives.
Security News
Ransomware payment rates hit an all-time low in 2024 as law enforcement crackdowns, stronger defenses, and shifting policies make attacks riskier and less profitable.