TaffyDB is an opensouce library that brings database features into your JavaScript applications.

How you ever noticed how JavaScript object literals look a lot like records? And that if you wrap a group of them up in an array you have something that atcs a lot like a database table? TaffyDB brings powerful database funtionality to that concept and rapidly improves the way you work with data inside of JavaScript.

What makes it sticky

• Extremely fast
• Powerful JavaScript centric data selection engine
• Database inspired features such as insert, update, unique, count, etc
• Robust cross browser support
• Easily extended with your own functions
• Compatible with any DOM library (jQuery, YUI, Dojo, etc)

xnxx popüler pornolar rus porno porno

Source: taffydb.com

1. INCLUDE JS FILES

<script src="https://github.com/typicaljoe/taffydb/raw/master/taffy.js"></script>

2. JAVASCRIPT

Let's create a DB to store some city information.

var cities = TAFFY();

You can add records on creation and via the .insert() method.

var cities = TAFFY([{name:"New York",state:"WA"},{name:"Las Vegas",state:"NV"},{name:"Boston",state:"MA"}]);
cities.insert({name:"Portland",state:"OR"});

Our city db is itself a function that accepts a filter object (an object that will be matched to records). Let's query for Boston. We will alert the .count() method to see our results.

alert(cities({name:"Boston"}).count());

You can chain together. Below we will get the first two records from the DB and use the .each() method to alert their names.

cities().limit(2).each(function (r) {alert(r.name)});

Updating data

cities({name:"New York"}).update({state:"NY"});

Sorting is a big part of TaffyDB using the .order() method.

alert(cities().order("name").first().name);

3. WRITING QUERIES

The heart of TaffyDB and any database is running queries against your data. This is done after creation of your database by calling the root function and building Filter Objects.

// Create a new empty database
var db = TAFFY();

// Run a query against the DB to return all rows
db();

// Real world example - remove all records
db().remove();

Looking up individual records

Every object within a TaffyDB collection has a ___id value set by TaffyDB. This value is not intended for you to know, but is useful when building dynamic applications. This can be used to lookup a record by passing it into the root function as a string.

// Looks up a record based on its id
db("T000008R000002");

// Real world example - update records "status" column
db("T000008R000002").update({status:"Active"});

This also works if you have a copy of the whole record.

// get the first record
var firstRecord = db().first();

// look up this record again
db(firstRecord);

// Real world example - update records "status" column
db(firstRecord).update({status:"Active"});

Using functions

To give you full control over the results of your query you can always pass in a function. Just have it return true if you want the record in your final results.

// functional example, returns all records
db(function () {
	return true;
});


// Real world example - function returns records with a status of active
db(function () {
	return (this.status == "Active") ? true : false;
});

Basic queries

TaffyDB uses a very JavaScript centric Filter Object for looking up queries. There is no string concatenation and you can quickly compose these by hand or dynamically from within your app. The filter object is compared against each record using some business rules and if it passes the record remains in the results set.

The most common Filter Object is used simply to check if a column is equal to value.

// does a match for column and value
db({column:"value"});


// Real world example - records with a status of active
db({status:"Active"});

This is the short form of this

// does a match for column and value
db({column:{is:"value"}});


// Real world example - records with a status of active
db({status:{is:"Active"}});

The "is" part of this expressions can be swapped out for a variety of other comparisons as listed below.

Using !(bang)

For any comparison operator you can quote it and add a ! sign to reverse the meaning.

// does a match for column that is not a value
db({column:{"!is":"value"}});

// Real world example - records with a status other than of active
db({status:{"!is":"Active"}});

Adding additional filters

Using the almighty comma you can add additional lookups to you Filter Object.

// does a match for column that is a value and column2 is a value
db({column:"value",column2:"value"});

// Real world example - records with a status of active and a role of admin
db({status:"Active",role:"Admin"});

You can also pass in additional Filter Objects into the function

// does a match for column that is a value and column2 is a value
db({column:"value"},{column2:"value"});

// Real world example - records with a status of active and a role of admin
db({status:"Active"},{role:"Admin"});

Using arrays for IN and OR

In a database you can use "in" to pass in a collection of values to compare against. This is possible in TaffyDB via the array.

// does a match for column that is one of two values
db({column:["value","value2"]);

// Real world example - records with a status of active or pending
db({status:["Active","Pending"]});

You can also pass in an array of Filter Objects with each one being treated as a logical OR.

// does a match for column that is one of two values
db([{column:"value"},{column:"value2"}]);

// Real world example - records with a status of active or pending
db([{status:"Active"},{status:"Pending"}]);

Bringing it all together

A real world example of a complex query.

// return records where the role is Admin and the status is Active. 
// Also return records where the role is Admin, the status is Pending, and the manager_review is true

db({role:"Admin"},[{status:"Active"},{status:"Pending",manager_review:true}]);

Comparison Operators

In addition to the default "is" operator there are a lot of other operators you can use to lookup records.

4. WORKING WITH DATA

Creating your database

You use the global TAFFY function to create a new database.

// Create a new empty database
var db = TAFFY();

// Create a new database a single object (first record)
var db = TAFFY({record:1,text:"example"})

// Create a new database using an array
var db = TAFFY([{record:1,text:"example"}])

// Create a new database using a JSON string
var db = TAFFY('[{"record":1,"text":"example"}]')

DB Queries

Once you have a database you'll be able to call your variable as function. This will setup a query and return a collection of methods to work with the results of that query.

db(); // returns all rows

DB Methods

In addition to the query function you have a couple of top level methods to use.

db.insert({column:"value"}); // inserts one record
						
db.insert({column:"value"},false); // insert but do not call onInsert event

db.order("columnname"); // orders collection by columnname

db.store("name"); // starts storing records in local storage

db.settings({template:{show:true}}); // sets the template to have a show value set to true by default on all records

db.settings({onUpdate:function () {alert(this)}}); // sets the onUpdate event

					

Query Object Methods

Any call to data collections root function will return a new query object. The methods below can be used to interact with the data.

db().update({column:"value"}); // sets column to "value" for all matching records

db().update("column","value"); // sets column to "value" for all matching records

db().update(function () {this.column = "value";return this;}); // sets column to "value" for all matching records


db().update({column:"value"},false); // update but do not call onUpdate event

db().remove(); // removes all matching records from the database
						
db().remove(true); // removes but do not call onRemove event

db().filter({column:value});
						
db().filter({column:value}).count();

collection({column:{gte:value}}).filter({column:{lte:value}}).count();
					

db().order("col1"); // sorts by col1 using a logical sort

db().order("col1 asec, col2 asec"); // sorts by col1 then col2

db().order("col1 desc"); // sorts by col1 descending

db().order("col1 logicaldesc"); // sorts by col1 using a logical sort descending
					

db().limit(15); // Limits returned results to first 15

db().start(15); // Starts returning results at record 15

db().each(function (record,recordnumber) {
	alert(record["balance"]);
}); // alerts the value of the balance column for each record

db().map(function (record,recordnumber) {
	return record.balance*0.2;
}); // returns an array of numbers that are each 20% of the actual balance for each record

db().callback(function () {
    alert(this.count()); // alert count of matching records					
});

db().get(); // returns an array of all matching records

db().stringify(); // returns a JSON array of all matching records

db().first(); // returns the first record out of all matching records.

db().last(); // returns the last record out of all matching records.

db().last("balance"); // returns the sum of the "balance" column.

db().min("balance"); // returns the lowest value of the "balance" column.

db().max("balance"); 
// returns the highest value of the "balance" column.

db().select("charges","credits","balance"); 
// returns an array of arrays in this format [[-24,20,-4]]

db().select("balance"); 
// returns an array of values in this format [-4,6,7,10]
					

db().distinct("title","gender"); 
// returns an array of arrays in this format [["Mr.","Male"],["Ms.","Female"]]

db().distinct("title"); 
// returns an array of values in this format ["Mr.","Ms.","Mrs."]

db().supplant("<tr><td>{balance}</td></tr>"); 
// returns a string in this format "<tr><td>-4</td></tr><tr><td>6</td></tr>"

db().supplant("<tr><td>{balance}</td></tr>",true); 
// returns an array of strings format ["<tr><td>-4</td></tr>","<tr><td>6</td></tr>"]

// City DB
city_db = TAFFY([
  {name:'New York',state:'NY'},
  {name:'Las Vegas',state:'NV'},
  {name:'Boston',state:'MA'}
]);

// State DB
state_db = TAFFY([
  {name: 'New York', abbreviation: 'NY'},
  {name: 'Nevada', abbreviation: 'NV'},
  {name: 'Massachusetts', abbreviation: 'MA'}
]);

// Conditional Join
city_db()
  .join( state_db, [ 'state', 'abbreviation' ]);

// Conditional Join with optional ===
city_db()
  .join( state_db, [ 'state', '===', 'abbreviation' ]);
  
// Conditional Join using function
city_db()
  .join( state_db, function (l, r) {
      return (l.state === r.abbreviation);
    });

http://www.javascriptoo.com/taffydb