Windows下安装配置SQLite和使用的教程

http://www.weste.net/2014/10-08/99347.html

什么是SQLite

SQLite是一款非常轻量级的关系数据库系统，支持多数SQL92标准。SQLite在使用前不需要安装设置，不需要进程来启动、停止或配置，而其他大多数SQL数据库引擎是作为一个单独的服务器进程，被程序使用某种内部进程通信(典型的是TCP／IP)，完成发送请求到服务器和接收查询结果的工作，SQLite不采用这种工作方式。使用SQLite时，访问数据库的程序直接从磁盘上的数据库文件读写，没有中间的服务器进程。使用SQLite一般只需要带上一个dll，就可以使用它的全部功能。

SQLite的主要应用场景有作为手机应用的数据库以及小型桌面软件的数据库。

安装使用SQLite

sqlite的官方下载地址为http://www.sqlite.org/download.html，上面提供了多种版本的sqlite，我选择下载名称为sqlite-shell-win32-x86-3080500.zip 的版本。下载后就直接解压到磁盘上，可以看到解压后只有sqlite3.exe这个文件。

接下来需要将sqlite加入到path环境变量中（加入环境变量是为了更加方便地使用sqlite），右键我的电脑-属性-高级系统设置-环境变量，在系统变量中找到Path，将解压的文件夹目录加入到后面（注意是文件夹目录，例如我本机的目录 E:Toolssqlite）。打开cmd，输入sqlite3，如果弹出以下消息，就表示成功了。

sqlite常用操作

1. 新建一个数据库文件

>命令行进入到要创建db文件的文件夹位置

>使用命令创建数据库文件: sqlite3 所要创建的db文件名称

>使用命令查看已附加的数据库文件: .databases

2. 打开已建立的数据库文件

>命令行进入到要打开的db文件的文件夹位置

>使用命令行打开已建立的db文件： sqlite3 文件名称（注意:假如文件名称不存在，则会新建一个新的db文件）

3. 查看帮助命令

>命令行直接输入sqlite3，进去到sqlite3命令行界面

>输入.help 查看常用命令

使用sqlite管理工具

shell脚本虽然提供了很强大的功能，但是使用起来还是不够方便，幸运的是，sqlite有很多开源而且优秀的DBMS！

这里我将使用一款叫做SQLiteSPY的软件，官网地址为http://www.yunqa.de/delphi/doku.php/products/sqlitespy/index，这个软件是绿色免安装版，解压直接运行就可以了。

可以看到，SQLiteSpy的界面布局和SQLServer很相近，操作起来很方便，这里就不在继续详细介绍了。（要知道的一点就是单纯使用这个软件也可以创建和使用sqlite数据库，不需要与上面提到的shell工具关联）

C#使用System.Data.SQLite.dll访问数据库

SQLite提供了用于C#调用的dll，下载地址为http://system.data.sqlite.org/index.html/doc/trunk/www/downloads.wiki，注意根据.NET FRAMEWORK版本下载对应的组件。在项目中只要引入System.Data.SQLite.dll这个组件，就可以实现数据库操作了。由于SQLite.dll实现了ADO.NET的接口，所以熟悉ADO.NET的人上手SQLite.dll也是非常快的。DEMO数据库表的结构为：

CREATE TABLE hero
(
    hero_id   INT          NOT NULL PRIMARY KEY,
    hero_name NVARCHAR(10) NOT NULL
);

比较需要注意到一点是数据库连接字符串，SQLite使用的连接字符串比较简单，只要写上数据库文件的引用路径就可以了。DEMO是一个控制台应用程序，增删查改的实例代码如下:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.Common;
using System.Data.SQLite;

namespace ConsoleApp
{
    class Program
    {
        static readonly string DB_PATH = "Data Source=E:/database/sqlite/arena.db";

        static void Select()
        {
            using (SQLiteConnection con = new SQLiteConnection(DB_PATH))
            {
                con.Open();
                string sqlStr = @"SELECT *
                                    FROM hero";
                using(SQLiteCommand cmd = new SQLiteCommand(sqlStr,con))
                {
                    using (SQLiteDataReader dr = cmd.ExecuteReader())
                    {
                        while (dr.Read())
                        {
                            Console.WriteLine(dr["hero_id"].ToString() + dr["hero_name"]);
                        }
                    }
                }
            }
        }

        static void Insert()
        {
            using (SQLiteConnection con = new SQLiteConnection(DB_PATH))
            {
                con.Open();
                string sqlStr = @"INSERT INTO hero
                                  VALUES
                                  (
                                      1,
                                      ＇萨满＇
                                  )";
                using(SQLiteCommand cmd = new SQLiteCommand(sqlStr,con))
                {
                    cmd.ExecuteNonQuery();
                }           
            }
        }

        static void Update()
        {
            using (SQLiteConnection con = new SQLiteConnection(DB_PATH))
            {
                con.Open();
                string sqlStr = @"UPDATE hero
                                     SET hero_name = ＇盗贼＇
                                   WHERE hero_id = 1";
                using (SQLiteCommand cmd = new SQLiteCommand(sqlStr, con))
                {
                    cmd.ExecuteNonQuery();
                }      
            }
        }

        static void Delete()
        {
            using (SQLiteConnection con = new SQLiteConnection(DB_PATH))
            {
                con.Open();
                string sqlStr = @"DELETE FROM hero";
                using (SQLiteCommand cmd = new SQLiteCommand(sqlStr, con))
                {
                    cmd.ExecuteNonQuery();
                }
            }
        }

        static void Main(string[] args)
        {
            Insert();
            Select();
            Update();
            Select();
            Delete();
        }
    }
}

SQLiteSpy是一个快速和紧凑的图形用户界面的SQLite数据库管理软件。它可以读取sqlite3文件并执行SQL。图形用户界面使得它很容易分析和操纵sqlite3的数据库。


注意：SQLiteSpy是免费供个人和教育用途，SQLiteSpy主要特点：
1、数据库一览：树状显示所有的架构，包括表，列，索引和触发器在数据库中包含的项目。按F5更新架构树，双击一个表或视图来显示它的数据，使用常用的命令的上下文菜单。
2、网格单元格编辑：表格单元格中编辑，显示一个表通过树状架构，选择一个单元格，然后按F2键调用编辑器。然后修改并确认您的更改写回到表里。
3、数据类型显示：本机的SQL数据类型显示不同的背景颜色来帮助检测类型错误。类型错误可能会导致性能下降或错误的SELECT结果集，防止NULL值与空字符串混淆。
4、完全的Unicode： SQLiteSpy具有完全支持SQLite的Unicode的能力。数据显示和输入是完全实现为Unicode，包括SQL命令。
5、多个SQL编辑：现代标签是用来编辑和显示的查询语句和结果比较容易多个SQL查询。 SQL查询执行输入或加载到SQL他们编辑。然后按F9键运行该查询，或Ctrl + F9来运行当前行或选择只。
6、时间测量： SQL执行的时间会自动测量和显示，以帮助优化查询。
7、正则表达式：在SQL关键字regexp是支持，并增加了完整的Perl的正则表达式语法5.10 SQLiteSpy。的实施，实现了利用DIRegEx库。
8、数学SQL函数：下面的SQL函数可用数学除了SQLite的默认：ACOS(), ASIN(), ATAN(), ATAN(), ATAN2(), CEIL(), CEILING(), COS(), COT(), DEGREES(), EXP(), FLOOR(), LN(), LOG(), LOG(), LOG2(), LOG10(), MOD(), PI(), POW(), RADIANS(), SIGN(), SIN(), SQRT(), TAN(), TRUNCATE().
9、数据压缩：压缩的SQL函数（）适用的zlib的紧缩到任何文本或BLOB值。
10、紧凑型结果储存：使用内部数据存储机制，以达到最佳的兼容SQLite的原生数据类型。因此，SQLiteSpy使用远低于其它的SQLite管理内存和更有效地处理大量的表。
11、内建的SQLite引擎： SQLiteSpy已建成一个单一的应用程序文件与SQLite数据库引擎可执行文件。不需要部署任何DLL文件，这使得SQLiteSpy更易于部署。
12、加密支持： SQLiteSpy可以阅读和修改加密的数据库文件由DISQLite3产生。 DISQLite3实现了自己的母语AES加密。这为不符合商业SQLite的加密扩展（SSE）的或任何其他第三方的实施提供兼容。
13、易安装和卸载：要运行SQLiteSpy，只需解压SQLiteSpy.exe文件到任何目录和执行文件。不需 要安装。刚开始时，该程序创建一个文件SQLiteSpy.db3（1 sqlite3的数据库）来存储的和设置。它不写任何其他文件或注册表。卸载一样只是简单的删除两个文件：应用程序的可执行文件和数据库文件。
http://www.yunqa.de/delphi/doku.php/products/sqlitespy/index

Hibernate Annotaction+Spring+SqlLite - Donie
 
 

  
  

   
   时间 2014-02-24 13:35:00 
   
    博客园-所有随笔区
  
  
  
  

   
   原文  
   
   http://www.cnblogs.com/Donie/p/Hibernate_Annotaction.html
  
  
  
  

   
   主题 
   
   NHibernate 
   
   Java
  
  
 
 
 
 

  
  

   
   
entity
   
   

    
    
    
    

     
     
package com.demo.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * CodeType entity. @author MyEclipse Persistence Tools
 */

@Entity
@Table(name = "CodeType")
public class CodeType implements java.io.Serializable {

    // Fields

    @Id
    @GeneratedValue
    @Column(name = "id")
    private Integer id;
    @Column(name = "typeName")
    private String typeName;

    // Constructors

    /** default constructor */
    public CodeType() {
    }

    /** full constructor */
    public CodeType(String typeName) {
        this.typeName = typeName;
    }

    // Property accessors

    public Integer getId() {
        return this.id;
    }

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

    public String getTypeName() {
        return this.typeName;
    }

    public void setTypeName(String typeName) {
        this.typeName = typeName;
    }

}
    
    
View Code
   
   
   
   
applicationContext.xml
   
   

    
    
    
    

     
     
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">


    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="org.sqlite.JDBC"></property>
        <property name="url"
            value="jdbc:sqlite:E:\CodeMgrSystem\SQlLiteAndHibernateDemo\CodeMgr.db">
        </property>
    </bean>
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <property name="dataSource">
            <ref bean="dataSource" />
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">com.demo.dialect.SQLiteDialect</prop>
            </props>
        </property>
        <property name="annotatedClasses">
            <list>
                <value>com.demo.entity.CodeType</value>
            </list>
        </property>
    </bean>
    
    <bean class="com.demo.dao.impl.CodeTypeDaoImpl" name="codeTypeDao" >
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
</beans>
    
    
View Code
   
   
   
   

    
    
    
    

     
     
package com.demo.dao.impl;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.demo.dao.CodeTypeDao;
import com.demo.entity.CodeType;

public class CodeTypeDaoImpl extends HibernateDaoSupport implements CodeTypeDao{

    public List<CodeType> getCodeTypes() {
        return getHibernateTemplate().find("from CodeType");
    }
    
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        CodeTypeDao dao = (CodeTypeDao) ac.getBean("codeTypeDao");
        List<CodeType> list = dao.getCodeTypes();
    
        System.out.println(list.size());
    }
}
    
    
View Code
   
   
   
   
 Hibernate不支持SqlLite的Dialect
   
   
SQLiteDialect.java
   
   

    
    
    
    

     
     
package com.demo.dialect;

/*
 * The author disclaims copyright to this source code.  In place of
 * a legal notice, here is a blessing:
 * 
 *    May you do good and not evil.
 *    May you find forgiveness for yourself and forgive others.
 *    May you share freely, never taking more than you give.
 *
 */
 
import java.sql.Types;
 
import org.hibernate.dialect.Dialect;
import org.hibernate.dialect.function.StandardSQLFunction;
import org.hibernate.dialect.function.SQLFunctionTemplate;
import org.hibernate.dialect.function.VarArgsSQLFunction;
import org.hibernate.Hibernate;
 
public class SQLiteDialect extends Dialect {
  public SQLiteDialect() {
    registerColumnType(Types.BIT, "integer");
    registerColumnType(Types.TINYINT, "tinyint");
    registerColumnType(Types.SMALLINT, "smallint");
    registerColumnType(Types.INTEGER, "integer");
    registerColumnType(Types.BIGINT, "bigint");
    registerColumnType(Types.FLOAT, "float");
    registerColumnType(Types.REAL, "real");
    registerColumnType(Types.DOUBLE, "double");
    registerColumnType(Types.NUMERIC, "numeric");
    registerColumnType(Types.DECIMAL, "decimal");
    registerColumnType(Types.CHAR, "char");
    registerColumnType(Types.VARCHAR, "varchar");
    registerColumnType(Types.LONGVARCHAR, "longvarchar");
    registerColumnType(Types.DATE, "date");
    registerColumnType(Types.TIME, "time");
    registerColumnType(Types.TIMESTAMP, "timestamp");
    registerColumnType(Types.BINARY, "blob");
    registerColumnType(Types.VARBINARY, "blob");
    registerColumnType(Types.LONGVARBINARY, "blob");
    // registerColumnType(Types.NULL, "null");
    registerColumnType(Types.BLOB, "blob");
    registerColumnType(Types.CLOB, "clob");
    registerColumnType(Types.BOOLEAN, "integer");
 
    registerFunction( "concat", new VarArgsSQLFunction(Hibernate.STRING, "", "||", "") );
    registerFunction( "mod", new SQLFunctionTemplate( Hibernate.INTEGER, "?1 % ?2" ) );
    registerFunction( "substr", new StandardSQLFunction("substr",Hibernate.STRING) );
    registerFunction( "substring", new StandardSQLFunction( "substr", Hibernate.STRING ) );
  }
 
  public boolean supportsIdentityColumns() {
    return true;
  }
 
  /*
  public boolean supportsInsertSelectIdentity() {
    return true; // As specify in NHibernate dialect
  }
  */
 
  public boolean hasDataTypeInIdentityColumn() {
    return false; // As specify in NHibernate dialect
  }
 
  /*
  public String appendIdentitySelectToInsert(String insertString) {
    return new StringBuffer(insertString.length()+30). // As specify in NHibernate dialect
      append(insertString).
      append("; ").append(getIdentitySelectString()).
      toString();
  }
  */
 
  public String getIdentityColumnString() {
    // return "integer primary key autoincrement";
    return "integer";
  }
 
  public String getIdentitySelectString() {
    return "select last_insert_rowid()";
  }
 
  public boolean supportsLimit() {
    return true;
  }
 
  protected String getLimitString(String query, boolean hasOffset) {
    return new StringBuffer(query.length()+20).
      append(query).
      append(hasOffset ? " limit ? offset ?" : " limit ?").
      toString();
  }
 
  public boolean supportsTemporaryTables() {
    return true;
  }
 
  public String getCreateTemporaryTableString() {
    return "create temporary table if not exists";
  }
 
  public boolean dropTemporaryTableAfterUse() {
    return false;
  }
 
  public boolean supportsCurrentTimestampSelection() {
    return true;
  }
 
  public boolean isCurrentTimestampSelectStringCallable() {
    return false;
  }
 
  public String getCurrentTimestampSelectString() {
    return "select current_timestamp";
  }
 
  public boolean supportsUnionAll() {
    return true;
  }
 
  public boolean hasAlterTable() {
    return false; // As specify in NHibernate dialect
  }
 
  public boolean dropConstraints() {
    return false;
  }
 
  public String getAddColumnString() {
    return "add column";
  }
 
  public String getForUpdateString() {
    return "";
  }
 
  public boolean supportsOuterJoinForUpdate() {
    return false;
  }
 
  public String getDropForeignKeyString() {
    throw new UnsupportedOperationException("No drop foreign key syntax supported by SQLiteDialect");
  }
 
  public String getAddForeignKeyConstraintString(String constraintName,
      String[] foreignKey, String referencedTable, String[] primaryKey,
      boolean referencesPrimaryKey) {
    throw new UnsupportedOperationException("No add foreign key syntax supported by SQLiteDialect");
  }
 
  public String getAddPrimaryKeyConstraintString(String constraintName) {
    throw new UnsupportedOperationException("No add primary key syntax supported by SQLiteDialect");
  }
 
  public boolean supportsIfExistsBeforeTableName() {
    return true;
  }
 
  public boolean supportsCascadeDelete() {
    return false;
  }
}
    
    
View Code