An Application Backend Service
Expand application possibilities
"This sounds too good to be true.
After tinkering around with CouchDB and MongoDB what I wanted was something in-between, and this sounds
- forum comment
- Create free-form data structures at run-time.
No schemas to create, ever. Simply start inserting data.
This enables new classes of applications with user-defined data sets,
flexibility of design throughout an application's lifecycle, ease of migration and rapid prot
- Complex structures and relations. Store and query complex structur
es and establish complex relations between them. All without fixed schemas. Import/export complete or partial jquery graphs in either a simple add-st
yle or a fully-referenced, non-duplicated update-style.
- Deep queries across complex structures via a simple join-free SQL syntax. e.g: WHERE $s:person.address.city='Rochester' AND $n:person.income>50000
- Unbounded, cross-relationship global querying.
For example, you can issue a query (SELECT $oid WHERE $s:city=
'Rochester') against a database that contains vendor.address.city objects and promotion.city objects and the query will return t
he oids of both matching vendor.address objects and matching promotion objects.
This single query takes the place of what would normally require 2 queries. And if yo
u had even more occurances of the attribute 'city' deeply spread throughout your database, it would
require more than 2 queries in other databases.
Additionally, SchemafreeSQL global queries can be optionally bounded to any sele
ct number of parents. For example you could use (WHERE $s:person.address.city) which would limit
your query to person.address objects no matter where they occur in your databa
se (e.g. under employees, or under family, etc.)
- Store as many blob and large-text attributes per object as you like.SchemafreeSQL does not place an extra constraint on the maximum number of blob or large-text attributes per object.
- Use full-text search. *Under your
control. Selectively index individual data attributes. Selectively query
full-text attributes in full combination with your standard SQL
queries. (e.g. SELECT firstname, lastname WHERE state='NY' AND
$workHistory.word()='lisp' AND $workHistory.word()='sql')
- Use MVCC-like options at a per-command level. For
example, you can execute a delayed delete which immediately removes
the data from query results, but at the same time is capable of
being recalled within the time-window you specify (e.g. 1 hour)
Useful when, for example, designing "undo" features for clients.
- Retrieve binary objects in a filesystem-like fashion using byte ranges. *
- Use built-in date shortcuts and date math on input data (e.g.
"+1M +5d" would calculate as 1 month and 5 days from now. "1/1/2020
-5m" would calculate as 5 minutes before midnight Dec 31st 2019). Year,
Month, Week, Day, Hour, Minute and Second math is possible.
* Upcoming Feature
SchemafreeSQL allows you to define your data structure at run-time, AND on a per-object basis.
This eliminates the painstaking design time spent on tables and foreign-keys.
This also frees you to change your data structure based on application demands - without having to worry about
massive table updates, possible lost data, and interruptions in service.
SchemafreeSQL delivers fast index-like queries without index configuration AND at the same time
delivers inserts at fast no-index speeds.
Instant database creation via cloud-based service.
- Atomic commit and rollback transaction support
- Hassle-free scaling in the cloud. Instant setup and simplified scaling accomodates your growth (e.g. larger storage, faster processing, etc.)
- Data redundancy and automatic backup
- Fast inserts. Free indexing technology keeps inserts fast. SchemafreeSQL is fast enough to store logging and analytics data.
- Lightweight, platform-neutral connection library - JSON over HTTP. Allows simplified, homogeneous access methods from any languge or platform
SchemafreeSQL is NOT
- a NoSQL database
SchemafreeSQL allows powerful SQL statements through it's enhanced SFQL query language which provides join-like operations with simple dot-notated relations.
- a pure SQL database
SchemafreeSQL eliminates the need to define zombie schemas and indexes and write JOINs.
- a document-based database
Several document-based database systems claim to be schemaless, yet when your data demands cross-document relations (esp. many-to-many),
something ugly rears its head which usually ends with you performing multiple queries and relating (or JOINing) data by hand.
This essentially forces the work away from the locality and fast speed of the database level, and up towards the remote and slow speed
of the client-to-database connection. The difference in speed is akin to the difference between registers and RAM, or between RAM and Disk.
The resultant design pattern often ends up a mirror of what you would have done in any standard SQL database, but without the low level optimizations that
a SQL database brings to such a pattern.
Additionally, with a non-native design pattern now in place to deal with your data relationships, concurrency issues may begin to surface.
In SchemafreeSQL, your data relationship possibilities are essentially unbounded; yet consistent in both design patterns, access patterns and performance.
- a SQL-layer on top of a map-reduce database
SchemafreeSQL data relationships are handled at the database level. Map-reduce SQL layers are implemented at higher and much slower levels.
- a ORM-layer
SchemafreeSQL data objects, although represented with the simplicity of ORM-styled dot-notated relationships, are completely independent of your programs' in-memory objects. Object-Relation-Mapping layers, on the other hand, create an impedance-mismatch between in-memory objects and database objects.
- a vector-based database
Although powerful, navigating vector-based databases can become complcated. SchemafreeSQL's simple-yet-powerful SFQL delivers consistent developer productivity.
Who's The Boss?
You, or your data?
We understand how difficult it is to fit an ever-changing application into a typical fixed-schema database.
We understand the yearning to change design to satisfy customer
demands, and know the fear of breaking the application which keeps you
from doing so.
We understand the outages which an application must endure while
the database system processes schema changes across the entirety of the
We understand how difficult it is to query and ad-hoc report against NoSQL databases.
Long story short…
SchemafreeSQL is your missing link to Rapid Database Development.
It allows you to dynamically alter your data design directly from your application code, run full-power
SFQL queries against your data in real-time, and dramatically speeds up design, development, execution and modification.
Your application can (and probably will) enforce a schema
on your data structure, but now
it's up to you as to how fixed or flexible, or how flat or
hierarchical it will be. And wherever your application leads you, you
always have full-featured, real-time queries at your command.
Show your data who's boss.