sqlsymphony_orm 0.2.8

The elegant and powerful SQLite3 ORM for Python

@mainpage

SQLSymphony

SQLSymphony: The elegant and powerful SQLite3 ORM for Python
Explore the docs »

Comparison with Alternatives . Why Choose SQLSymphony · Key Features · Getting Started · Basic Usage · Documentation · License

SQLSymphony: The elegant and powerful SQLite3 ORM for Python

SQLSymphony is a lightweight ✨, powerful 💪, and high-performance⚡️, Object-Relational Mapping (ORM) library for Python, designed to simplify the interaction with SQLite3 databases. It provides a Pythonic, object-oriented interface that allows developers to focus on their application's bussiness logic rather than the underlying database management.

SQLSymphony ORM - powerful and simple ORM for python

🌟 Comparison with Alternatives

Feature	SqlSymphony	SQLAlchemy	Peewee
💫 Simplicity	✔️	✔️	✔️
🚀 Performance	✔️	❌	✔️
🌐 Database Agnosticism	❌	✔️	❌
📚 Comprehensive Documentation	✔️	✔️	✔️
🔥 Active Development	✔️	✔️	❌
💻 Audit changes & reverts	✔️	❌	❌
⚡ ASYNC Support	COMING SOON	✔️	❌

(back to top)

🤔 Why Choose SqlSymphony?

✨ Simplicity: SqlSymphony offers a straightforward and intuitive API for performing CRUD operations, filtering, sorting, and more, making it a breeze to work with databases in your Python projects.

💪 Flexibility: The library is designed to be database-agnostic, allowing you to switch between different SQLite3 implementations without modifying your codebase.

⚡️ Performance: SqlSymphony is optimized for performance, leveraging techniques like lazy loading and eager loading to minimize database queries and improve overall efficiency.

📚 Comprehensive Documentation: SqlSymphony comes with detailed documentation, including usage examples and API reference, to help you get started quickly and efficiently.

🔍 Maintainability: The codebase follows best practices in software engineering, including principles like SOLID, Clean Code, and modular design, ensuring the library is easy to extend and maintain.

🧪 Extensive Test Coverage: SqlSymphony is backed by a comprehensive test suite, ensuring the library's reliability and stability.

(back to top)

📚 Key Features

• Intuitive API: Pythonic, object-oriented interface for interacting with SQLite3 databases.
• Database Agnosticism: Seamlessly switch between different SQLite3 implementations.
• Performance Optimization: Lazy loading, eager loading, and other techniques for efficient database queries.
• Comprehensive Documentation: Detailed usage examples and API reference to help you get started.
• Modular Design: Clean, maintainable codebase that follows best software engineering practices.
• Extensive Test Coverage: Robust test suite to ensure the library's reliability and stability.

(back to top)

🚀 Getting Started

SQLSymphony is available on PyPI. Simply install the package into your project environment with PIP:

pip install sqlsymphony_orm

Once installed, you can start using the library in your Python projects. Check out the documentation for detailed usage examples and API reference.

(back to top)

💻 Usage Examples

(back to top)

Creating a Model

from sqlsymphony_orm.datatypes.fields import IntegerField, CharField, TextField
from sqlsymphony_orm.models.orm_models import Model
from sqlsymphony_orm.database.manager import SQLiteDatabaseSession
from sqlsymphony_orm.database.connection import SQLiteDBConnector


class Video(Model):
	__tablename__ = "Videos"
	__database__ = "videos.db"

	id = IntegerField(primary_key=True)
	author = CharField(max_length=32)
	title = CharField(max_length=64, null=False)
	description = TextField(null=False)
	views = IntegerField(null=False, default=0)

	def __repr__(self):
		return f"<Video {self.id} {self.title}>"


class Comment(Model):
	__tablename__ = "Comments"
	__database__ = "videos.db"

	id = IntegerField(primary_key=True)
	video = IntegerField(null=False)

	def __repr__(self):
		return f"<Comment {self.id} {self.video}>"


# Simple hook
def hello():
	print("hello")


video = Video(
	author="Alexeev",
	title="How to make your own ORM in python",
	description="Big video about python coding",
)
video.save(ignore=True)
video.commit()

video2 = Video(author="Alexeev", title="Test", description="An another video", views=1)
video2.save(ignore=True)
video2.commit()
video2.update(views=102)
video2.delete()
video2.commit()
video2.rollback_last_action()
video2.commit()

comment = Comment(video=video2.pk)
comment.add_hook("save", hello) # register hook (exec before sql query exec)
comment.save(ignore=True)
comment.commit()

print(video.objects.fetch())
print(comment.objects.fetch())
print(video2.get_audit_history())

Cache Performance

from sqlsymphony_orm.performance.cache import cached, SingletonCache, InMemoryCache


@cached(SingletonCache(InMemoryCache, max_size=1000, ttl=60))
def fetch_data(param1: str, param2: str):
	return {'data': f'{param1} and {param2}'}

result1 = fetch_data('foo', 'bar')
print(result1) # caching
result2 = fetch_data('foo', 'bar')
print(result2) # cached

result3 = fetch_data('baz', 'qux')
print(result3) # not cached

RAW SQL Query

from sqlsymphony_orm.database.connection import SQLiteDBConnector
from sqlsymphony_orm.queries import raw_sql_query

connector = SQLiteDBConnector().connect('database.db')


@raw_sql_query(connector=connector, values=('John',))
def insert():
	return 'INSERT INTO Users (name) VALUES (?)'

Session SQL Query Executor

from sqlsymphony_orm.database.manager import SQLiteDatabaseSession
from sqlsymphony_orm.database.connection import SQLiteDBConnector

with SQLiteDatabaseSession(connector, commit=True) as session:
	session.fetch(
		"CREATE TABLE IF NOT EXISTS BALABOLA (id INTEGER PRIMARY KEY, name VarChar(32))"
	)

Performing CRUD Operations

Create a new record

user = User(name='Charlie')
user.save()
user.commit()

user2 = User(name='John')
user2.save()
user2.commit()

print(user.objects.fetch())

Update record

user2 = User(name="Carl")
user2.save()
user2.commit()

user2.update(name="Bobby")
user2.commit()

print(user2.objects.fetch())

Delete record

user = User(name="Charlie")
user.save()
user.commit()

user2 = User(name="Carl")
user2.save()
user2.commit()

user3 = User(name="John")
user3.save()
user3.commit()

user3.delete() # delete user3
# OR
user3.delete(field_name="name", field_value="Carl") # delete user2

user3.commit()

print(user.objects.fetch())

Filter

user = User(name="Charlie")
user.save()
user.commit()

user2 = User(name="Carl")
user2.save()
user2.commit()

user2.update(name="Bobby")
user2.commit()

user3 = User(name="John")
user3.save()
user3.commit()

user3.delete()
user3.commit()

print(user.objects.fetch())
print(user.objects.filter(name="Bobby"))

(back to top)

🤝 Contributing

We welcome contributions from the community! If you'd like to help improve SqlSymphony, please check out the contributing guidelines to get started.

(back to top)

💬 Support

If you encounter any issues or have questions about SqlSymphony, please:

• Check the documentation for answers
• Open an issue on GitHub
• Reach out to the project maintainers via the mailing list

(back to top)

☑️ Todos

• Create Migrations system and Migrations Manager
• Create ForeignKey field
• Create RelationShip

(back to top)

🔮 Roadmap

Our future goals for SqlSymphony include:

• 📚 Expanding support for more SQLite3 features
• 🚀 Improving performance through further optimizations
• ✅ Enhancing the testing suite and code coverage
• 🌍 Translating the documentation to multiple languages
• 🔧 Implementing advanced querying capabilities
• 🚀 Add asynchronous operation mode
• ☑️ Add more fields

(back to top)

License

Distributed under the GNU GPL v3 License. See LICENSE for more information.

(back to top)