I am trying to wrap my head around doing object oriented analysis and design when your canonical data source is Cassandra.
Specifically:
How do I maintain data consistency if data is duplicated among the denormalized cassandra tables?
How do I maintain a clean object design? Do I have to have a reference diagram that shows how my domain models map to the denormalized tables?
Thanks.
Essentially, the same way you would if you used a RDBMS as the data-store. Create OO domain-model classes. Access the data-store through an abstract interface, the persistence layer, which accepts and provides objects of those classes. Internally, have the persistence layer convert to and from your domain-model classes and Cassandra tables.
When looking at tutorials there is often a delineation between a schema and a model, particularly when dealing with mongoose/mongodb.
This makes porting over to postgresql somewhat confusing, as 'models' don't seem to exist under that system. What is the difference the two approaches?
For example, what would be a postgres/sql ORM equivalent of this line?
(mongoose and express.js):
var userSchema = schema.define('local', {
username: String,
password: String,
});
module.exports = mongoose.model('User', userSchema);
In mongoose, a schema represents the structure of a particular document, either completely or just a portion of the document. It's a way to express expected properties and values as well as constraints and indexes. A model defines a programming interface for interacting with the database (read, insert, update, etc). So a schema answers "what will the data in this collection look like?" and a model provides functionality like "Are there any records matching this query?" or "Add a new document to the collection".
In straight RDBMS, the schema is implemented by DDL statements (create table, alter table, etc), whereas there's no direct concept of a model, just SQL statements that can do highly flexible queries (select statements) as well as basic insert, update, delete operations.
Another way to think of it is the nature of SQL allows you to define a "model" for each query by selecting only particular fields as well as joining records from related tables together.
In other ORM systems like Ruby on Rails, the schema is defined via ActiveRecord mechanisms and the model is the extra methods your Model subclass adds that define additional business logic.
A schema is fundamentally describing the data construct of a
document (in MongoDB collection). This schema defines the name of each item of data, and the type of data, whether it is a string, number, date, Boolean, and so on.
A model is a compiled version of the schema. One instance of the model will map to one document in the database.
It is the model that handles the reading, creating, updating, and deleting of documents.
A document in a Mongoose collection is a single instance of a model. So it makes sense that if we're going to work with our data then it will be through the model.
A single instance of a model (like a User instance in var User = mongoose.model('User', userSchema);) maps directly to a single document in the database.
With this 1:1 relationship, it is the model that handles all document interaction - creating, reading, saving, and deleting. This makes the model a very powerful tool.
Taken from "Mongoose for Application Development", by Simon Holmes, 2013
I imagine models as classes created from a schema (maybe I am mistaken).
MongoDB stores everything in BSON , which is a binary format. A simple Hello World BSON document might look like this internally:
\x16\x00\x00\x00\x02hello\x00\x06\x00\x00\x00world\x00\x00. A computer can deal with all that mumbo-jumbo, but that's hard to read for humans. We want something we can easily understand, which is why developers have created the concept of a database model. A model is a representation of a database record as a nice object in your programming language of choice. In this case, our models will be JavaScript objects. Models can serve as simple objects that store database values, but they often have things like data validation, extra methods, and more. As you’ll see, Mongoose has a lot
of those features.
Taken from "Express in Action", by Evan Hahn, 2016
In Short:
A Mongoose model is a wrapper on the Mongoose schema. A Mongoose schema defines the structure of the document, default values, validators, etc., whereas a Mongoose model provides an interface to the database for creating, querying, updating, deleting records, etc.
Reference: Introduction to Mongoose for MongoDB - FCC
I have a table or tables in sqlServer. I want to take data from database and keep this table's data into objects like class, but I dont want to keep this data into dataset.
What are those ways to keep data into objects taking data from database?
How can I pass data into object but not in dataset or datatable?
ORM is what you should be looking for.
For .Net framework you can look into
Entity Framework
LINQ to SQL
NHibernate
Dapper
ORM is the solution as mentioned above.....
Better use entity frame work that is good for this purpose.......it will creates entity classes with all your tables in the database.
In short: as it is suggested in the comment, some type of ORM (Object relational mapping) will do that magic for you.
Good references on this topic are the followings:
4 Benefits of Object-Relational Mapping (ORM)
ORM mapping data to objects
DataObjects.Net - ORM Framework for RAD - Introduction
Edit: To choose the right ORM for your problem, look at this Wikipedia article
List of object-relational mapping software.
Looking at the Mongoose ODM docs, it doesn't really say much about what are ObjectId's and how they can be used. I think its something like foreign keys in MongoDB?
If so, Embedded Documents seem to achieve the same purpose, when do I use which?
It would be very worthwhile to read the MongoDB documentation or a quick MongoDB intro such as The Little MongoDB Book (it's free) for some background on MongoDB concepts.
To answer your question:
An ObjectID is a unique 12-byte identifier which can be generated by MongoDB as the primary key (_id) for a collection. There is a specification for the ObjectID.
A DBRef (database reference) is an ObjectID referencing an object in another collection. A DBRef does require require another query to fetch the related object, and is a convention supported by the client drivers rather than MongoDB server. The Mongoid equivalent is called referenced relations.
Embedded documents are nested arrays or subdocuments within a document. In Mongoid these are embedded relations.
The approach to data modelling and schema design in MongoDB is very different from relational databases. There are (intentionally) no joins or foreign keys, but the document-oriented approach allows large amounts of related data to be stored and fetched in a single document. Depending on how you plan to query and update your data, embedding or linking may be a more suitable choice. The schema design page on the MongoDB wiki has some helpful tips to get you started.
I am starting with CouchDB. What is the accepted best practice to utilize databases? A single database per application storing all kinds of entities with smth like "_type" property to discriminate one from another or a separate database for each kind of entity?
One database with lots of different types of document, so you can take advantage of View Collation. Note that top-level names prefixed with an underscore, e.g. _type, are reserved for CouchDB.