The Data Access Layer (DAL) is the layer of a system that exists between the business logic layer and the persistence / storage layer. A DAL might be a single class, or it might be composed of multiple Data Access Objects (DAOs). It may have a facade over the top for the business layer to talk to, hiding the complexity of the data access logic. It might be a third-party object-relational mapping tool (ORM) such as Hibernate.

DAL is an architectural term, DAOs are a design detail.

A data access layer will contain many data access objects. 

It&#39;s primary role is to decouple the business logic from the database logic and implementation.

For example the DAL may have a single method that will retrieve data from several tables, queries or stored procedures via one or more data access objects.

Changes to the database structure, DAOs, stored procedures or even database type should not incur changes to the business logic and this is down to the decoupling provided by the DAL.



Executor seems like a clean abstraction. When would you want to use Thread directly rather than rely on the more robust executor?

When should we use Java&#39;s Thread over Executor?

I&#39;m new to the OOP paradigm, so there&#39;s probably a simple explanation for this question...

Do you always need to declare public object-wide variables in a class? For example:

    &lt;?php
    
    class TestClass
    {
    	var $declaredVar;

    	function __construct()
    	{
    		$this-&gt;declaredVar = &quot;I am a declared variable.&quot;;
    		$this-&gt;undeclaredVar = &quot;I wasn&#39;t declared, but I still work.&quot;;
    	}
    	
    	function display()
    	{
    		echo $this-&gt;declaredVar . &quot;&lt;br /&gt;&quot;;
    		echo $this-&gt;undeclaredVar;
    		echo &quot;&lt;br /&gt;&lt;br /&gt;&quot;; 
    	}
    }
    
    $test = new TestClass;
    $test-&gt;display();
    
    $test-&gt;declaredVar = &quot;The declared variable was changed.&quot;;
    $test-&gt;undeclaredVar = &quot;The undeclared variable was changed.&quot;;
    
    $test-&gt;display();
    
    ?&gt;

In this code, even though `$declaredVar` is the only declared variable, `$undeclaredVar` is just as accessible and useable--it seems to act as if I had declared it as public. 

If undeclared class variables are always accessible like that, what&#39;s the point of declaring them all up front? 



When should I declare variables in a PHP class?

Having studied Java at school I am quite familiar with the DAO-pattern([Data access object][1]). However at work I use .NET. In .NET there is often talk about the DAL([Data Access Layer][2]). To me their purpose seems quite similar. So the question is are DAO and DAL basically the same thing? Is the term DAL only made up so it wouldn&#39;t be mixed up with [Data Access Objects][3]?


  [1]: http://en.wikipedia.org/wiki/Data_Access_Object
  [2]: http://en.wikipedia.org/wiki/Data_access_layer
  [3]: http://en.wikipedia.org/wiki/Data_Access_Objects

What is the difference between DAO and DAL?

<p>Having studied Java at school I am quite familiar with the DAO-pattern(<a href="http://en.wikipedia.org/wiki/Data_Access_Object" target="_blank" rel="noopener noreferrer">Data access object</a>). However at work I use .NET. In .NET there is often talk about the DAL(<a href="http://en.wikipedia.org/wiki/Data_access_layer" target="_blank" rel="noopener noreferrer">Data Access Layer</a>). To me their purpose seems quite similar. So the question is are DAO and DAL basically the same thing? Is the term DAL only made up so it wouldn't be mixed up with <a href="http://en.wikipedia.org/wiki/Data_Access_Objects" target="_blank" rel="noopener noreferrer">Data Access Objects</a>?</p>


I&#39;m designing a new app based on JPA/Hibernate, Spring and Wicket. The distinction between the DAO and Service layers isn&#39;t that clear to me though. According to Wikipedia, DAO is 

&gt; an object that provides an abstract
&gt; interface to some type of database or
&gt; persistence mechanism, providing some
&gt; specific operations without exposing
&gt; details of the database.

I was wondering whether a DAO could contain methods that don&#39;t really have to do much with data access, but are way easier executed using a query? For example &quot;get a list of all airlines that operate on a certain set of airports&quot;? It sounds to me to be more of a service-layer method, but I&#39;m not sure if using JPA EntityManager in the service layer is an example of good practice?

DAO and Service layers (JPA/Hibernate + Spring)

Firstly it is possible that I am asking something that has been asked and answered before but I could not get a search result back. We define transactional annotations on service layer typical spring hibernate crud is usually

&gt; _Controller-&gt;Manager-&gt;Dao-&gt;Orm ._

I now have a situation where I need to choose between the domain model based on client site. 
Say client A is using my domain model all is good but then an other client site would give me a web service and not be using our domain model.

Which layer should I be replacing . I believe it has to be DAO which will be getting me data from web service and sending it back.i.e two separately written DAO layers and plugged in based on scenario.

I have now realized that we have been doing tight coupling (if there is such a thing or say not having loose coupling) when we put `@Transactional` in Service layer. So many brains can not be wrong or are they (I doubt it). 

So question is &quot;Where should &quot;`@Transactional`&quot; be placed Service Layer or DAO ?&quot; and is it service layer downwards I should be replacing.


----------

Eleven years on and still relevant . If I look back at the project somethings were obviously wrong with my understanding of Domain model back then . I was regarding ORM layer as domain model and we wanted to work with ORM and detached entities and no have any data mapping and not have any DTOs. That was the trend those days. These days Domain Model is not the ORM and having a proper Domain model and using ORM or Webservices are datasources take care of this issue. Like many pointed out yes Service is the right place for it and have proper domain model and not regard JPA (ORM) as domain model.

Where should &quot;@Transactional&quot; be placed Service Layer or DAO

What is the best way to perform bulk inserts into an MS Access database from .NET?  Using ADO.NET, it is taking way over an hour to write out a large dataset.

*Note that my original post, before I &quot;refactored&quot; it, had both the question and answer in the question part.  I took Igor Turman&#39;s suggestion and re-wrote it in two parts - the question above and followed by my answer.*

Writing large number of records (bulk insert) to Access in .NET/C#

I am trying to use the `org.springframework.orm.jdo.TransactionAwarePersistenceManagerFactoryProxy` in my Spring project, but I am not sure how to use it or whether it&#39;s exactly what I am looking for. I realize it can help make my DAOs work with a plain JDO `PersistenceManagerFactory`. Another question is: what happens if the proxy doesn&#39;t get made properly? Can I still use it to access my factory to create a transaction aware persistence manager? If the object managed by the factory is a singleton, does this change things? Why not just access the PersistenceManagerFactory directly? Perhaps `PersistenceManagerFactoryUtils.getPersistenceManager` would be more suited to my needs? Can `getObject` return null?

Unsure if I understand TransactionAwarePersistenceManagerFactoryProxy

I was going through a document and I came across a term called `DAO`. I found out that it is a Data Access Object. Can someone please explain me what this actually is? 

I know that it is some kind of an interface for accessing data from different types of sources, in the middle of this little research of mine I bumped into a concept called data source or data source object, and things got messed up in my mind. 

I really want to know what a `DAO` is programmatically in terms of where it is used. How it is used? Any links to pages that explain this concept from the very basic stuff is also appreciated.

Data access object (DAO) in Java

I&#39;m near the beginning of a new project and (gasp!) for the first time ever I&#39;m trying to include unit tests in a project of mine.

I&#39;m having trouble devising some of the unit tests themselves.  I have a few methods which have been easy enough to test (pass in two values and check for an expected output).  I&#39;ve got other parts of the code which are doing more complex things like running queries against the database and I&#39;m not sure how to test them.

    public DataTable ExecuteQuery(SqlConnection ActiveConnection, string Query, SqlParameterCollection Parameters)
    {
        DataTable resultSet = new DataTable();
        SqlCommand queryCommand = new SqlCommand();
        try
        {
            queryCommand.Connection = ActiveConnection;
            queryCommand.CommandText = Query;
    
            if (Parameters != null)
            {
                foreach (SqlParameter param in Parameters)
                {
                     queryCommand.Parameters.Add(param);
                }
            }
    
            SqlDataAdapter queryDA = new SqlDataAdapter(queryCommand);
            queryDA.Fill(resultSet);
        }
        catch (Exception ex)
        {
            //TODO: Improve error handling
            Console.WriteLine(ex.Message);
        }
    
        return resultSet;
    }

This method essentially takes in all the necessary bits and pieces to extract some data from the database, and returns the data in a DataTable object.

The first question is probably the most complex: What should I even test in a situation like this?

Once that&#39;s settled comes the question of whether or not to mock out the database components or try to test against the actual DB.

How to write unit tests for database calls

What is the difference between Data Access Objects (DAO) and Repository patterns? I am developing an application using Enterprise Java Beans (EJB3), Hibernate ORM as infrastructure, and Domain-Driven Design (DDD) and Test-Driven Development (TDD) as design techniques.

What is the difference between DAO and Repository patterns?

I am writing a project in Django and I see that 80% of the code is in the file `models.py`. This code is confusing and, after a certain time, I cease to understand what is really happening.

Here is what bothers me:

 1. I find it ugly that my model level (which was supposed to be
    responsible only for the work with data from a database) is also
    sending email, walking on API to other services, etc. 
 2. Also, I find it unacceptable to place business logic in the view, because
    this way it becomes difficult to control. For example, in my
    application there are at least three ways to create new
    instances of `User`, but technically it should create them uniformly. 
 3. I do not always notice when the methods and
    properties of my models become non-deterministic and when they develop
    side effects.

Here is a simple example. At first, the `User` model was like this:

    class User(db.Models):

        def get_present_name(self):
            return self.name or &#39;Anonymous&#39;

        def activate(self):
            self.status = &#39;activated&#39;
            self.save()
    
Over time, it turned into this:

    class User(db.Models):

        def get_present_name(self): 
            # property became non-deterministic in terms of database
            # data is taken from another service by api
            return remote_api.request_user_name(self.uid) or &#39;Anonymous&#39; 

        def activate(self):
            # method now has a side effect (send message to user)
            self.status = &#39;activated&#39;
            self.save()
            send_mail(&#39;Your account is activated!&#39;, &#39;…&#39;, [self.email])


What I want is to separate entities in my code:

1. **Entities of my database, persistence level: What data does my application keep?**
2. **Entities of my application, business logic level: What does my application do?**


What are the good practices to implement such an approach that can be applied in Django?

Content Type	Original Author	Original Content on Stackoverflow
Question	simoraman	View Question on Stackoverflow
Solution 1 - Dao	Matt Howells	View Answer on Stackoverflow
Solution 2 - Dao	ChrisBD	View Answer on Stackoverflow

What is the difference between DAO and DAL?

Dao Problem Overview

Dao Solutions

Solution 1 - Dao

Solution 2 - Dao

When should I declare variables in a PHP class?

When should we use Java's Thread over Executor?

Attributions