In order to improve the development of JStORM i decided to move it to Mercurial.
I couldn`t find the copy of the svn repository from my old server so i had to start from a clean Mercurial repository so there is no history.
The new mercurial repository is on bitbucket: JStORM repository.
Thanks to Christopher Thatcher,JStORM now fully supports Mozilla Rhino,using JDBC to connect to either SQLite or MySQL.
There were few difficulties when trying to adapt JStORM to work with Rhino,for some reason Rhino doesn`t enumerate object properties in the order they were declared,that is the reason that tests have a number prefix.
Other problem was that Rhino doesn`t let you change the function name property which hold the name of the function,the problem was that i was keeping the table name on the model in a property called name,the fix was just to not use it since it can be reached using model._meta.tableName
The support is in the trunk
Just wanted to announce that JStORM now supports Classic ASP,with support for SQL Server and Access(with a bug that still need to be fixed).
I hope that this will make easier to maintain those old ASP sites that aren`t willing to die ;)
The support is in the trunk
P.S.: a special thanks goes to Nathan Smith for writing this code!
i wanted to see how much time(and changes to the code) it will take me to add a Adobe AIR support,so i tried it today and it took me 2 hours(!) to add a full support for Adobe AIR with minimal code change!
the only thing that doesn`t work is introspection since AIR doesn`t have the sqlite_master table(which is the sqlite standard) you can see the bug here
the support is in the svn trunk.
UPDATE:Adobe AIR support is in svn trunk
I am happy to announce the first beta of JStORM,a complete rewrite of GearsORM to support multiple backends,currently supporting Jaxer(MySQL and Sqlite) and Google Gears(Sqlite).
This version is a complete rewrite of GearsORM,it changed the way it works internally and also the API.
The first change is that every model have it own connection to the database,this is in order to enable different models connected to different databases.
Another interesting change is the JStORM.Query class,this class allows for easily querying the models.
a query instance can be obtain by calling the all method of the model,lets define a simple model:
var Person = new JStORM.Model({
name:"Person",
fields:
{
firstName:new JStORM.Field({type:"String",maxLength:25}),
lastName:new JStORM.Field({type:"String",maxLength:25}),
},
connection:"default"
});
For example to print all the persons in the database:
Person.all().each(function(person)
{
console.log(person.firstName);
});
What the all function do is to create a new instance of JStORM.Query for Person model.
Other function that return a query is filter,filter return a query filtered by a criteria,for example:
var katzFamily = Person.filter("lastName = ?","Katz");
katzFamily.each(function(person)
{
console.log(person.firstName);
});
A thing to note about Query is that it is lazy evaluated,so invoking the method filter or all doesn`t query the database until you start iterating over the result.
Queries can be filtered many times to create a AND expression between criterias(note that each call to filter create a new query object):
var uriels = Person.filter("firstName = ?","Uriel");
var urielKatzs = uriels.filter("lastName = ?","Katz");
console.log("People with first name Uriel: " + uriels.count());
console.log("People with name Uriel Katz: " + urielKatzs.count());
Query objects have various methods for example the count method:
var numberOfMembers = Person.filter("lastName = ?","Katz").count();
console.log("Katz family have " +numberOfFamilyMembers + " members");The count method return the number of objects that matched the criteria of the Query object,it use the SQL COUNT function.
There is also the remove method,which delete all the objects that match the criteria:
Person.filter("firstName = ?","Uriel").remove();The remove method uses the SQL DELETE statment.
This early release is to show the new api and support for Jaxer,there is some stuff lacking that were in GearsORM:
I can`t show the all api in this post,currently there is no documentation,so you can see examples for api usage in the unit tests.
In the next weeks i will focus on testing,writing documentation and improving JStORM for final release, keep checking the blog for updates on JStORM.
links:
P.S.:As always bug reports and fixes are welcome,also if anyone wants to help either with the code and documentation(especially in this,since my english isn`t that good).
UPDATE:a new version is here.
New features in this version:
The most important update in this version is of course transaction support.
SQLite is known for really bad write preformence when not working with transactions.
While developing transaction support for GearsORM i had to write a test,in that test it execute 100 inserts and 100 updates,this test take about 15 seconds for the inserts and about 10 seconds for the updates without transactions,when using transactions for each set it takes about 377ms for the inserts and 200ms for the updates that is about 39 times faster!
To use transactions just wrap all the code that you want to be in a transaction into a function and call GearsORM.Transaction with that function like this:
GearsORM.Transaction(function()
{
new Person({name:"John"}).save();
new Person({name:"Doe"}).save();
});
This will execute a BEGIN query before running the function and a COMMIT query if everything went ok ,else it will execute ROLLBACK.
This make all the queries between BEGIN to COMMIT to run in a transaction and to run faster :)
Self relations are a great way to use a tree structure in a database,this is how it look:
var TreeNode = new GearsORM.Model({
name:"TreeNode",
fields:
{
data:new GearsORM.Fields.String({maxLength:25}),
parent:new GearsORM.Fields.OneToMany(
{related:"TreeNode",allowNull:true}),
childs:new GearsORM.Fields.ManyToOne(
{related:"TreeNode"})
}
});
this model have both ManyToOne and OneToMany,the only required is OneToMany since it is a db field,the ManyToOne comes only to provide a easy way to get the child nodes.
one new option added to OneToMany is the allowNull this add a way to say that it is not related to any one,this is very important with self relations since the first row inserted to a table with self relation can`t be related to any row because there is no rows!
lets create a few nodes:
var root = new TreeNode({data:"i am the root",parent:null}).save();
var node1 = new TreeNode({data:"i am node 1",parent:root}).save();
var node2 = new TreeNode({data:"i am node 2",parent:root}).save();
in this example we have the root node which doesn`t have a parent,node1 and node2 both have a parent which is root.
this means that both node1 and node2 are childs of root.
getting the childs of root is like using a normal ManyToOne relation:
root.childs.select().each(function(node)
{
console.log(node.data);
});
this will output to the console(if using firebug):
i am node1
i am node2.
we can also delete from a self relation:
root.childs.remove("data = ?",["i am node1"]);this will remove node1 but it will make sure that node1 was related to root,if there was another node that had data set to i am node1 it wouldn`t be deleted since it is not a child of root.
a now for count,count is method to retrive how much objects(i.e. rows) match a query.
for example Person.count() will return how much pepole there is in the database,count can also use a where clause,like this:
Person.count("lastName = ?",["Katz"])
this will return the number of pepole that have the lastName set to Katz.
the difference between doing Person.select().toArray().length to using Person.count() is that count use the COUNT sql function therefore it is alot more efficient than doing a select then creating a array and then getting the count.
link to packed version here.
more information in the project homepage.
feature requests are always welcome :) (as well bug reports)
UPDATE:a new version is here.
this is a minor update to GearsORM that fixes two bugs,one small bug reported by Evgeny Tyazhev and other known bug in which m2m tables forigen keys aren`t enforced.
another nice thing is a new utility class(or should i say object) GearsORM.Introspection which contain a model(sqliteMasterModel) which maps to sqlite_master table which provide information about the schema,also there is a function GearsORM.Introspection.doesTableExist used to check if a table exist when creating m2m triggers.
in this version i moved from JSDoc to NaturalDocs and added a auto-generated documentaion,also i finally setup up the svn with apache.
so with no futher delay,the links:
some things for the next version:
feature requests are always welcomed.
big thanks goes to Evgeny Tyazhev for helping me in finding the bugs and fixing them.
UPDATE:a new version is here.
So after more than a month since i released a proof of concept of a ORM for Google Gears,i am happy to release the first(official) version of GearsORM .
This is a complete rewrite of the code,this version support relations(both many to one and many to many with automatic table creation),easy loading and saving objects from JSON,real foreign keys(SQLite doesn`t support them) using triggers and many more stuff.
Since i am a big fan of examples i will try to show the new api by a example(the code is fully documented,but i still don`t have a official documentation).
for this example we will make a blog like system(Post,Comment and Tag models).
let define the models first:
var Post = new GearsORM.Model({
name:"Post",
fields:
{
title:new GearsORM.Fields.String({maxLength:256}),
body:new GearsORM.Fields.String({maxLength:5000}),
tags:new GearsORM.Fields.ManyToMany({related:"Tag"}),
comments:new GearsORM.Fields.ManyToOne({
related:"Comment"})
}
});
var Comment = new GearsORM.Model({
name:"Comment",
fields:
{
name:new GearsORM.Fields.String({maxLength:50}),
email:new GearsORM.Fields.String({maxLength:75}),
body:new GearsORM.Fields.String({maxLength:1000}),
post:new GearsORM.Fields.OneToMany({
related:"Post",onDeleteCascade:true})
}
});
var Tag = new GearsORM.Model({
name:"Tag",
fields:
{
name:new GearsORM.Fields.String({maxLength:25}),
posts:new GearsORM.Fields.ManyToMany({related:"Post"})
}
});
now we have three models: Post,Comment and Tag.
a model have a function used to create the table for the model,if the table already exist nothing will happen.
so my recommendation is to put the calls to createTable right after models definition,like this:
Tag.createTable();
Post.createTable();
Comment.createTable();
This will insure that all the tables exist(but this doesn't insure that the table definition is correct,in case that the table already exist).
Now that we have everything configured(in terms of models and tables) we can start to insert some data.
For example to create a tag:
var testTag = new Tag();
testTag.name = "TestTag";
testTag.save();
This will create a new Tag object,set its name and save it to the database(this happen when you call the save method of the Tag instance).
there is a shorter way to create a instance and set its values,you do it like this:
var testTag = new Tag({name:"TestTag"}).save();Now for relations:
var myTestPost = new Post({
title:"my test post",
body:"my test post body"
}).save();
myTestPost.tags.add(testTag);
This will create a new post and add a relation to testTag.
myTestPost.tags is a ManyToMany relation field,which have these methods:
select anywhere in GearsORM return a ResultIterator which is a helper class to iterate over the results of a select.
ResultIterator define these methods:
a model(in our example Post,Tag and Comment) define these methods:
this is just a glimpse of the api,for more info go to GearsORM homepage(there is no documentation yet but stay tuned).
a simple demo here,packed version of the source here and trac view of code here
UPDATE:a new version is here.
i saw Google Gears and i thought :"nice finally i have some kind of client side storage in browsers other than Firefox".(i know that only IE and Firefox are supported,but safari support is on the way,and in gears group they have been talking about opera support,also this is a open source project)
but then i thought:"damn i hate to write sql",so i started to write a simple ORM something like SQLObject but way simpler.
this short script give you a way to declare your tables as objects and provide a nicer OO interface than the normal Google Gears api.
so to define a table you do it like this:
var Person = new GearsOrm.Model("Person",
{
firstName:GearsOrm.Fields.String({maxLength:25}),
lastName:GearsOrm.Fields.String({maxLength:25})
});
the first argument is the table name to use in the db.
the second argument is a object that define all the fields in the table,
the keys are the field names and the values are the field types.
there 4 field types: Integer,Float,TimeStamp and String.
each of this get a object which define sql properties:
now that we have our tables defined,we need to create them,no problem just call the createTable() function of the model and the table will be created for you(if it is already created it won`t do anything),like this:
Person.createTable();
now for some real work,to insert a row to the database:
var myself = Person.insert(["Uriel","Katz"]);
alert(myself.firstName);
alert(myself.lastName);
that simple!,this will insert a Person with first name "Uriel" and last name "Katz" and will return a object
that have firstName set to "Uriel" and lastName set to "Katz".
now that we have something in the db we can retrive it using select method of the model:
var persons = Person.select();
var current;
while(current = persons.next())
{
alert(current.firstName + ":" +current.lastName);
}
what Person.select() do is to return a object with a function next(like a iterator in some languages), when calling to next it return a person object,when there is no more persons to retrieve it will return null and by that will stop the while loop.
select can also get a expression that will be used as the WHERE in the sql query,like this:
Person.select("firstName = 'Uriel'")
or using bind variables(recommended,since it auto quote the values and prevent SQL injection attacks):
Person.select("firstName = ?",["Uriel"])
now for delete,delete works like select but it must get a expression,let say we want to delete all the pepole with last name Cats(common misspell of the name Katz):
Person.delete_("lastName = ?",["Cats"])
this will delete all the Persons(i.e. all the rows in the table Person) that have their last name is Cats.
NOTE: delete_ is used instead of delete since it is a keyword in JavaScript.
the model have also a function called dropTable that will drop the table if it exists.
note that there is no support for relations but that can be add easily.
a simple demo is here and source code here.
NOTE: by default GearsOrm use the database name "gears.orm" if you want to use different name just add a line just after the include of gears_orm.js like this:
GearsOrm.dbName = "myDataBaseName";
Design © 2006 by the the undersigned
| blog system and port by Uriel Katz. © 2008
