Database cannot be opened due to inaccessible files or insufficient memory or disk space

Database 'db' cannot be opened due to inaccessible files or insufficient memory or disk space. See the SQL Server errorlog for details. 


Here is Solution/Fix/workaround of this problem.

1. check the DB status, most of the time , it will return 1

use master
select databaseproperty('dbname','isShutdown')

2. Change the database to offline to clear the db status 

use master
alter database dbname set offline

3. Now change the database to online, at this step log file and data files will be verified by sql server


use master
alter database dbname set online

Serialization

Serialization is a mechanism by which you can save or transfer the state of an object by converting it to a byte stream. This can be done in java by implementing Serialiazable interface. Serializable is defined as a marker interface which needs to be implemented for transferring an object over a network or persistence of its state to a file. Since its a marker interface, it does not contain any methods. Implementation of this interface enables the conversion of object into byte stream and thus can be transferred. The object conversion is done by the JVM using its default serialization mechanism.Serialization is required for a variety of reasons. It is required to send across the state of an object over a network by means of a socket. One can also store an object’s state in a file. Additionally, manipulation of the state of an object as streams of bytes is required.

The serialization runtime associates with each serializable class a version number, called a serialVersionUID, which is used during deserialization to verify that the sender and receiver of a serialized object have loaded classes for that object that are compatible with respect to serialization.

What would happen if the SerialVersionUID of an object is not defined?

If you don't define serialVersionUID in your serilizable class, Java compiler will make one by creating a hash code using most of your class attributes and features. When an object gets serialized, this hash code is stamped on the object which is known as the SerialVersionUID of that object. This ID is required for the version control of an object. SerialVersionUID can be specified in the class file also. In case, this ID is not specified by you, then Java compiler will regenerate a SerialVersionUID based on updated class and it will not be possible for the already serialized class to recover when a class field is added or modified. Its recommended that you always declare a serialVersionUID in your Serializable classes.

Hibernate

Hibernate ORM (Hibernate in short) is an object-relational mapping framework for the Java language, providing a framework for mapping an object-oriented domain model to a traditional relational database.

Persistence:

Hibernate ORM is concerned with helping your application to achieve persistence.

we would like the state of (some of) our objects to live beyond the scope of the JVM so that the same state is available later.

Hibernate vs myBatis

Hibernate works well for case 1 allowing you to just make a POJO and persist/update it. It also does this quickly, unless your domain is quite large.

myBatis is great for fetch queries (case 2) where you just want an answer. Hibernate would attempt to load the entire object graph and you'd need to start tuning queries with LazyLoading tricks to keep it working on a large domain. This is important when running complex analytic queries that don't even return entity objects. Hibernate only offers SqlQuery and bean Transformers in this case with huge default types like BigDecimal, while myBatis could easily map to a simple POJO non-entity.

These two cases are the difference between Commands where you want to change the domain data and Responses where you just want to fetch some data.

So, consider these two cases and what your application does. If you have a simple domain and just fetch information, use myBatis. If you have a complex domain and persist entities, use Hibernate.

MyBatis

MyBatis is a first class persistence framework with support for custom SQL, stored procedures and advanced mappings. MyBatis eliminates almost all of the JDBC code and manual setting of parameters and retrieval of results. MyBatis can use simple XML or Annotations for configuration and map primitives, Map interfaces and Java POJOs (Plain Old Java Objects) to database records.

Simple example:

1. database.properties

db.driver=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/mydb
db.username= ************
db.password= ************


2. configuration.xml

<configuration>
    <properties resource="database.properties"/>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${db.driver}"/>
                <property name="url" value="${db.url}"/>
                <property name="username" value="${db.username}"/>
                <property name="password" value="${db.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/mybatis/demo/user/UserMapper.xml"/>
    </mappers>
</configuration>

3. UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.mybatis.my.user.dao.UserDAO"></mapper>

4. ConnectionFactory Class

package com.mybatis.my.util;

import java.io.Reader;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class ConnectionFactory {
    private static SqlSessionFactory sqlMapper;
    private static Reader reader;
    static{
        try{
            reader    = Resources.getResourceAsReader("configuration.xml");
            sqlMapper = new SqlSessionFactoryBuilder().build(reader);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
    public static SqlSessionFactory getSession(){
        return sqlMapper;
    }
}

5. UserVO Class

package com.mybatis.my.user.vo;

import java.io.Serializable;


public class UserVO implements Serializable {
    
    private static final long serialVersionUID = 4872640461000241018L;
    private long id;
    private String fullName;
    private String address;
    private String email;
    private String mobile;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getFullName() {
        return fullName;
    }

    public void setFullName(String fullName) {
        this.fullName = fullName;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getMobile() {
        return mobile;
    }

    public void setMobile(String mobile) {
        this.mobile = mobile;
    }
    
     @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        UserVO other = (UserVO) obj;
        if (fullName == null) {
            if (other.fullName != null)
                return false;
        } else if (!fullName.equals(other.fullName))
            return false;
        if (id != other.id)
            return false;
        return true;
    }

}


6. UserDAO Interface


package com.mybatis.my.user.dao;

import java.util.List;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import com.mybatis.my.user.vo.UserVO;

public interface UserDAO {
    String MQL_GET_ALL_USERS  = "select * from users";
    String MQL_GET_USER_BY_ID = "select * from users where id = #{id}";
    String MQL_CREATE_USER    = "insert into users (fullName, email, address, mobile) values (#{fullName},#{email},#{address},#{mobile})";
    String MQL_UPDATE_USER    = "update users set fullName=#{fullName}, email=#{email}, address=#{address}, mobile=#{mobile} where id=#{id}";
    String MQL_DELETE_USER    = "delete from users where id=#{id}";
    @Select(MQL_GET_ALL_USERS)
    public List<uservo> getAllUsers() throws Exception;
    @Select(MQL_GET_USER_BY_ID)
    public UserVO getUserById(long id) throws Exception;
    @Insert(MQL_CREATE_USER)
    public int doCreateUser(UserVO vo) throws Exception;
    @Update(MQL_UPDATE_USER)
    public int doUpdateUser(UserVO vo) throws Exception;
    @Delete(MQL_DELETE_USER)
    public int doDeleteUser(UserVO vo) throws Exception; 
}



7. UserBO Class

package com.mybatis.my.user.bo;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import com.mybatis.my.util.ConnectionFactory;
import com.mybatis.my.user.dao.UserDAO;
import com.mybatis.my.user.vo.UserVO;

public class UserBO {
    public List<uservo> getUsers() throws Exception{
        SqlSession session = ConnectionFactory.getSession().openSession();
            UserDAO dao =session.getMapper(UserDAO.class);
            List<uservo> users= dao.getAllUsers();
        session.close();
        return users;
    }
    public UserVO getUserById(long id) throws Exception{
        SqlSession session = ConnectionFactory.getSession().openSession();
            UserDAO dao =session.getMapper(UserDAO.class);
            UserVO user =dao.getUserById(id);
        session.close();
        return user;
    }
    public UserVO createUser(UserVO vo) throws Exception{
        SqlSession session = ConnectionFactory.getSession().openSession();
            UserDAO dao =session.getMapper(UserDAO.class);
            dao.doCreateUser(vo);
        session.commit();
        session.close();
        return vo;
    }
    public UserVO updateUser(UserVO vo) throws Exception{
        SqlSession session = ConnectionFactory.getSession().openSession();
            UserDAO dao =session.getMapper(UserDAO.class);
            dao.doUpdateUser(vo);
        session.commit();
        session.close();
        return vo;
    }
    public int deleteUser(UserVO vo) throws Exception{
        SqlSession session = ConnectionFactory.getSession().openSession();
            UserDAO dao =session.getMapper(UserDAO.class);
            int cnt= dao.doDeleteUser(vo);
        session.commit();
        session.close();
        return cnt;
    }
    public static void main(String a[])throws Exception{
        UserBO bo = new UserBO();
        UserVO vo= new UserVO();
        vo.setAddress("Test");
        vo.setEmail("test@gmail.com");
        vo.setFullName("Full Name");
        vo.setMobile("12411515");
        System.out.println(bo.createUser(vo));
        System.out.println(bo.getUsers());
        vo= bo.getUserById(1);
        vo.setAddress("Test Updated11 Address");
        vo.setEmail("testupdated@gmail.com");
        vo.setFullName("Full Name Test");
        vo.setMobile("1241151511");
        bo.updateUser(vo);
        vo=bo.getUserById(1);
        System.out.println(vo);
        bo.deleteUser(vo);
    }

}

Spring MVC 3.2 Execution Flow

Step 1: First request will be received by DispatcherServlet
Step 2: DispatcherServlet will take the help of HandlerMapping and get to know theController class name associated with the given request
Step 3: So request transfer to the Controller, and then controller will process the request by executing appropriate methods and returns ModeAndView object (contains Model data and View name) back to the DispatcherServlet
Step 4: Now DispatcherServlet send the model object to the ViewResolver to get the actual view page
Step 5: Finally DispatcherServlet will pass the Model object to the View page to display the result

AJAX VS JQUERY

AJAX

1. AJAX = Asynchronous JavaScript and XML.
2. AJAX is a technique for creating fast and dynamic web pages.
3. AJAX allows web pages to be updated asynchronously by exchanging small amounts of data with the server behind the scenes. This means that it is possible to update parts of a web page, without reloading the whole page.
4. Classic web pages, (which do not use AJAX) must reload the entire page if the content should change.

JQUERY

1. JQuery is a lightweight, "write less, do more", JavaScript library.
2. The purpose of jQuery is to make it much easier to use JavaScript on your website.
3. jQuery takes a lot of common tasks that require many lines of JavaScript code to accomplish, and wraps them into methods that you can call with a single line of code.
4. jQuery also simplifies a lot of the complicated things from JavaScript, like AJAX calls and DOM manipulation.