ServiceStack.OrmLite

Follow @ServiceStack or join the Google+ Community for updates, or StackOverflow or the Customer Forums for support.

Fast, Simple, Typed ORM for .NET

OrmLite's goal is to provide a convenient, DRY, config-free, RDBMS-agnostic typed wrapper that retains a high affinity with SQL, exposing intuitive APIs that generate predictable SQL and maps cleanly to (DTO-friendly) disconnected POCO's. This approach makes easier to reason-about your data access making it obvious what SQL is getting executed at what time, whilst mitigating unexpected behavior, implicit N+1 queries and leaky data access prevalent in Heavy ORMs.

OrmLite was designed with a focus on the core objectives:

• Provide a set of light-weight C# extension methods around .NET's impl-agnostic System.Data.* interfaces
• Map a POCO class 1:1 to an RDBMS table, cleanly by conventions, without any attributes required.
• Create/Drop DB Table schemas using nothing but POCO class definitions (IOTW a true code-first ORM)
• Simplicity - typed, wrist friendly API for common data access patterns.
• High performance - with support for indexes, text blobs, etc.
  • Amongst the fastest Micro ORMs for .NET.
• Expressive power and flexibility - with access to IDbCommand and raw SQL
• Cross platform - supports multiple dbs (currently: Sql Server, Sqlite, MySql, PostgreSQL, Firebird) running on both .NET and Mono platforms.

In OrmLite: 1 Class = 1 Table. There should be no surprising or hidden behaviour, the Typed API that produces the Querydoesn't impact how results get intuitively mapped to the returned POCO's which could be different to the POCO used to create the query, e.g. containing only a subset of the fields you want populated.

Any non-scalar properties (i.e. complex types) are text blobbed by default in a schema-less text field using any of the available pluggable text serializers. Support for POCO-friendly references is also available to provide a convenient API to persist related models. Effectively this allows you to create a table from any POCO type and it should persist as expected in a DB Table with columns for each of the classes 1st level public properties.

Download

8 flavours of OrmLite is on NuGet:

• ServiceStack.OrmLite.SqlServer
• ServiceStack.OrmLite.Sqlite
• ServiceStack.OrmLite.PostgreSQL
• ServiceStack.OrmLite.MySql
• ServiceStack.OrmLite.MySqlConnector

These packages contain both .NET Framework v4.5 and .NET Standard 2.0 versions and supports both .NET Framework and .NET Core projects.

The .Core packages contains only .NET Standard 2.0 versions which can be used in ASP.NET Core Apps running on the .NET Framework:

• ServiceStack.OrmLite.SqlServer.Core
• ServiceStack.OrmLite.PostgreSQL.Core
• ServiceStack.OrmLite.MySql.Core
• ServiceStack.OrmLite.Sqlite.Core

Unofficial Releases maintained by ServiceStack Community:

• ServiceStack.OrmLite.Oracle
• ServiceStack.OrmLite.Firebird
• ServiceStack.OrmLite.VistaDb

Latest v4+ on NuGet is a commercial release with free quotas.

Getting Started with OrmLite and AWS RDS

OrmLite has great support AWS's managed RDS Databases, follow these getting started guides to help getting up and running quickly:

• PostgreSQL
• Aurora
• MySQL
• MariaDB
• SQL Server

Docs and Downloads for older v3 BSD releases

Copying

Since September 2013, ServiceStack source code is available under GNU Affero General Public License/FOSS License Exception, see license.txt in the source. Alternative commercial licensing is also available.

Contributing

Contributors need to approve the Contributor License Agreement before submitting pull-requests, see the Contributing wikifor more details.

---

Usage

First Install the NuGet package of the RDBMS you want to use, e.g:

PM> Install-Package ServiceStack.OrmLite.SqlServer

Each RDBMS includes a specialized dialect provider that encapsulated the differences in each RDBMS to support OrmLite features. The available Dialect Providers for each RDBMS is listed below:

SqlServerDialect.Provider      // SQL Server Version 2012+
SqliteDialect.Provider         // Sqlite
PostgreSqlDialect.Provider     // PostgreSQL 
MySqlDialect.Provider          // MySql
OracleDialect.Provider         // Oracle
FirebirdDialect.Provider       // Firebird
VistaDbDialect.Provider        // Vista DB

SQL Server Versions

There are a number of different SQL Server dialects to take advantage of features available in each version. For any version before SQL Server 2008 please use SqlServer2008Dialect.Provider, for any other version please use the best matching version:

SqlServer2008Dialect.Provider  // SQL Server <= 2008
SqlServer2012Dialect.Provider  // SQL Server 2012
SqlServer2014Dialect.Provider  // SQL Server 2014
SqlServer2016Dialect.Provider  // SQL Server 2016
SqlServer2017Dialect.Provider  // SQL Server 2017+

Configure OrmLiteConnectionFactory

To configure OrmLite you need the DB Connection string along the Dialect Provider of the RDBMS you're connecting to, e.g:

var dbFactory = new OrmLiteConnectionFactory(
    connectionString,  
    SqlServerDialect.Provider);

If you're using an IOC you can register OrmLiteConnectionFactory as a singleton, e.g:

container.Register(c => 
    new OrmLiteConnectionFactory(":memory:", SqliteDialect.Provider)); //InMemory Sqlite DB

You can then use the dbFactory to open ADO.NET DB Connections to your database. If connecting to an empty database you can use OrmLite's Create Table API's to create any tables you need based solely on the Schema definition of your POCO and populate it with any initial seed data you need, e.g:

using (var db = dbFactory.Open())
{
    if (db.CreateTableIfNotExists())
    {
        db.Insert(new Poco { Id = 1, Name = "Seed Data"});
    }

    var result = db.SingleById(1);
    result.PrintDump(); //= {Id: 1, Name:Seed Data}
}

OrmLite Interactive Tour

The best way to learn about OrmLite is to take the OrmLite Interactive Tour which lets you try out and explore different OrmLite features immediately from the comfort of your own browser without needing to install anything:

Type Converters

You can customize, enhance or replace how OrmLite handles specific .NET Types with the new OrmLite Type Converters.

There's also support for SQL Server-specific SqlGeography, SqlGeometry and SqlHierarchyId Types, See docs on SQL Server Types for instructions on how to enable them.

Async API Overview

A quick overview of Async API's can be seen in the class diagram below:

Essentially most of OrmLite public API's now have async equivalents of the same name and an additional conventional *Async suffix. The Async API's also take an optional CancellationToken making converting sync code trivial, where you just need to add the Async suffix and await keyword, as can be seen in the Customer Orders UseCase upgrade to Async diff , e.g:

Sync:

db.Insert(new Employee { Id = 1, Name = "Employee 1" });
db.Save(product1, product2);
var customer = db.Single(new { customer.Email }); 

Async:

await db.InsertAsync(new Employee { Id = 1, Name = "Employee 1" });
await db.SaveAsync(product1, product2);
var customer = await db.SingleAsync(new { customer.Email });

Effectively the only Data Access API's that doesn't have async equivalents are *Lazy APIs yielding a lazy sequence (incompatible with async) as well as Schema DDL API's which are typically not used at runtime.

For a quick preview of many of the new Async API's in action, checkout ApiSqlServerTestsAsync.cs.

Async RDBMS Providers

Currently only a limited number of RDBMS providers offer async API's, which at this time are only:

• SQL Server .NET 4.5+
• PostgreSQL .NET 4.5+
• MySQL .NET 4.5+

We've also added a .NET 4.5 build for Sqlite as it's a common use-case to swapout to use Sqlite's in-memory provider for faster tests. But as Sqlite doesn't provide async API's under-the-hood we fallback to pseudo async support where we just wrap its synchronous responses in Task results.

API Examples

OrmLite provides terse and intuitive typed API's for database querying from simple lambda expressions to more complex LINQ-Like Typed SQL Expressions which you can use to construct more complex queries. To give you a flavour here are some examples:

Querying with SELECT

int agesAgo = DateTime.Today.AddYears(-20).Year;
db.Select(x => x.Birthday >= new DateTime(agesAgo, 1, 1) 
                    && x.Birthday <= new DateTime(agesAgo, 12, 31));

db.Select(x => Sql.In(x.City, "London", "Madrid", "Berlin"));

db.Select(x => x.Earnings <= 50);

db.Select(x => x.Name.StartsWith("A"));

db.Select(x => x.Name.EndsWith("garzon"));

db.Select(x => x.Name.Contains("Benedict"));

db.Select(x => x.Rate == 10 && x.City == "Mexico");

db.Select(x => x.Rate.ToString() == "10"); //impicit string casting

db.Select(x => "Rate " + x.Rate == "Rate 10"); //server string concatenation

Convenient common usage data access patterns

OrmLite also includes a number of convenient API's providing DRY, typed data access for common queries:

Person person = db.SingleById(1);

Person person = db.Single(x => x.Age == 42);

var q = db.From()
          .Where(x => x.Age > 40)
          .Select(Sql.Count("*"));

int peopleOver40 = db.Scalar(q);

int peopleUnder50 = db.Count(x => x.Age < 50);

bool has42YearOlds = db.Exists(new { Age = 42 });

int maxAgeUnder50 = db.Scalar(x => Sql.Max(x.Age), x => x.Age < 50);

var q = db.From()
    .Where(x => x.Age == 27)
    .Select(x => x.LastName);
    
List results = db.Column(q);

var q = db.From()
          .Where(x => x.Age < 50)
          .Select(x => x.Age);

HashSet results = db.ColumnDistinct(q);

var q = db.From()
          .Where(x => x.Age < 50)
          .Select(x => new { x.Id, x.LastName });

Dictionary results = db.Dictionary(q);

var q = db.From()
          .Where(x => x.Age < 50)
          .Select(x => new { x.Age, x.LastName });

Dictionary> results = db.Lookup(q);

INSERT, UPDATE and DELETEs

To see the behaviour of the different APIs, all examples uses this simple model

public class Person
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int? Age { get; set; }
}

UPDATE

In its most simple form, updating any model without any filters will update every field, except the Id which is used to filter the update to this specific record:

db.Update(new Person { Id = 1, FirstName = "Jimi", LastName = "Hendrix", Age = 27});

If you supply your own where expression, it updates every field (inc. Id) but uses your filter instead:

db.Update(new Person { Id = 1, FirstName = "JJ" }, p => p.LastName == "Hendrix");

One way to limit the fields which gets updated is to use an Anonymous Type:

db.Update(new { FirstName = "JJ" }, p => p.LastName == "Hendrix");

Or by using UpdateNonDefaults which only updates the non-default values in your model using the filter specified:

db.UpdateNonDefaults(new Person { FirstName = "JJ" }, p => p.LastName == "Hendrix");

UpdateOnly

As updating a partial row is a common use-case in Db's, we've added a number of methods for just this purpose, named UpdateOnly.

The lambda syntax lets you update only the fields listed in property initializers, e.g:

db.UpdateOnly(() => new Person { FirstName = "JJ" });

The second argument lets you specify a filter for updates:

db.UpdateOnly(() => new Person { FirstName = "JJ" }, where: p => p.LastName == "Hendrix");

Alternatively you can pass in a POCO directly, in which case the first expression in an UpdateOnly statement is used to specify which fields should be updated:

db.UpdateOnly(new Person { FirstName = "JJ" }, onlyFields: p => p.FirstName);

db.UpdateOnly(new Person { FirstName = "JJ", Age = 12 }, 
    onlyFields: p => new { p.FirstName, p.Age });

db.UpdateOnly(new Person { FirstName = "JJ", Age = 12 }, 
    onlyFields: p => new[] { "Name", "Age" });

When present, the second expression is used as the where filter:

db.UpdateOnly(new Person { FirstName = "JJ" }, 
    onlyFields: p => p.FirstName, 
    where: p => p.LastName == "Hendrix");

Instead of using the expression filters above you can choose to use an SqlExpression builder which provides more flexibility when you want to programatically construct the update statement:

var q = db.From()
    .Update(p => p.FirstName);

db.UpdateOnly(new Person { FirstName = "JJ", LastName = "Hendo" }, onlyFields: q);

Using an Object Dictionary:

var updateFields = new Dictionary {
    [nameof(Person.FirstName)] = "JJ",
};

db.UpdateOnly(updateFields, p => p.LastName == "Hendrix");

Using a typed SQL Expression:

var q = db.From()
    .Where(x => x.FirstName == "Jimi")
    .Update(p => p.FirstName);
          
db.UpdateOnly(new Person { FirstName = "JJ" }, onlyFields: q);

Updating existing values

The UpdateAdd API provides several Typed API's for updating existing values:

//Increase everyone's Score by 3 points
db.UpdateAdd(() => new Person { Score = 3 }); 

//Remove 5 points from Jackson Score
db.UpdateAdd(() => new Person { Score = -5 }, where: x => x.LastName == "Jackson");

//Graduate everyone and increase everyone's Score by 2 points 
db.UpdateAdd(() => new Person { Points = 2, Graduated = true });

//Add 10 points to Michael's score
var q = db.From()
    .Where(x => x.FirstName == "Michael");
db.UpdateAdd(() => new Person { Points = 10 }, q);

Note: Any non-numeric values in an UpdateAdd statement (e.g. strings) are replaced as normal.

INSERT

Insert's are pretty straight forward since in most cases you want to insert every field:

db.Insert(new Person { Id = 1, FirstName = "Jimi", LastName = "Hendrix", Age = 27 });

Partial Inserts

You can use InsertOnly for the rare cases you don't want to insert every field

db.InsertOnly(() => new Person { FirstName = "Amy" });

Alternative API using an SqlExpression

var q = db.From()
    .Insert(p => new { p.FirstName });

db.InsertOnly(new Person { FirstName = "Amy" }, onlyFields: q)

DELETE

Like updates for DELETE's we also provide APIs that take a where Expression:

db.Delete(p => p.Age == 27);

Or an SqlExpression:

var q = db.From()
    .Where(p => p.Age == 27);

db.Delete(q);

As well as un-typed, string-based expressions:

db.Delete(where: "Age = @age", new { age = 27 });

Delete from Table JOIN

Using a SqlExpression to delete rows by querying from a joined table:

var q = db.From()
    .Join((x, y) => x.Id == y.PersonId)
    .Where(x => x.Id == 2);

db.Delete(q);

Not supported in MySql

API Overview

The API is minimal, providing basic shortcuts for the primitive SQL statements:

OrmLite makes available most of its functionality via extension methods to add enhancments over ADO.NET's IDbConnection, providing a Typed RDBMS-agnostic API that transparently handles differences in each supported RDBMS provider.

Create Tables Schemas

OrmLite is able to CREATE, DROP and ALTER RDBMS Tables from your code-first Data Models with rich annotations for controlling how the underlying RDBMS Tables are constructed.

The Example below utilizes several annotations to customize the definition and behavior of RDBMS tables based on a POCOspublic properties:

public class Player
{
    public int Id { get; set; }                     // 'Id' is PrimaryKey by convention

    [Required]
    public string FirstName { get; set; }           // Creates NOT NULL Column

    [Alias("Surname")]                              // Maps to [Surname] RDBMS column
    public string LastName { get; set; }

    [Index(Unique = true)]                          // Creates Unique Index
    public string Email { get; set; }

    public List PhoneNumbers { get; set; }   // Complex Types blobbed by default

    [Reference]
    public List GameItems { get; set; }   // 1:M Reference Type saved separately

    [Reference]
    public Profile Profile { get; set; }            // 1:1 Reference Type saved separately
    public int ProfileId { get; set; }              // 1:1 Self Ref Id on Parent Table

    [ForeignKey(typeof(Level), OnDelete="CASCADE")] // Creates ON DELETE CASCADE Constraint
    public Guid SavedLevelId { get; set; }          // Creates Foreign Key Reference

    public ulong RowVersion { get; set; }           // Optimistic Concurrency Updates
}

public class Phone                                  // Blobbed Type only
{
    public PhoneKind Kind { get; set; }
    public string Number { get; set; }
    public string Ext { get; set; }
}

public enum PhoneKind
{
    Home,
    Mobile,
    Work,
}

[Alias("PlayerProfile")]                            // Maps to [PlayerProfile] RDBMS Table
[CompositeIndex(nameof(Username), nameof(Region))]  // Creates Composite Index
public class Profile
{
    [AutoIncrement]                                 // Auto Insert Id assigned by RDBMS
    public int Id { get; set; }

    public PlayerRole Role { get; set; }            // Native support for Enums
    public Region Region { get; set; }
    public string Username { get; set; }
    public long HighScore { get; set; }

    [Default(1)]                                    // Created in RDBMS with DEFAULT (1)
    public long GamesPlayed { get; set; }

    [CheckConstraint("Energy BETWEEN 0 AND 100")]   // Creates RDBMS Check Constraint
    public short Energy { get; set; }

    public string ProfileUrl { get; set; }
    public Dictionary Meta { get; set; }
}

public enum PlayerRole                              // Enums saved as strings by default
{
    Leader,
    Player,
    NonPlayer,
}

[EnumAsInt]                                         // Enum Saved as int
public enum Region
{
    Africa = 1,
    Americas = 2,
    Asia = 3,
    Australasia = 4,
    Europe = 5,
}

public class GameItem
{
    [PrimaryKey]                                    // Specify field to use as Primary Key
    [StringLength(50)]                              // Creates VARCHAR COLUMN
    public string Name { get; set; }

    public int PlayerId { get; set; }               // Foreign Table Reference Id

    [StringLength(StringLengthAttribute.MaxText)]   // Creates "TEXT" RDBMS Column 
    public string Description { get; set; }

    [Default(OrmLiteVariables.SystemUtc)]           // Populated with UTC Date by RDBMS
    public DateTime DateAdded { get; set; }
}

public class Level
{
    public Guid Id { get; set; }                    // Unique Identifer/GUID Primary Key
    public byte[] Data { get; set; }                // Saved as BLOB/Binary where possible
}

We can drop the existing tables and re-create the above table definitions with:

using (var db = dbFactory.Open())
{
    if (db.TableExists())
        db.DeleteAll();                      // Delete ForeignKey data if exists

    //DROP and CREATE ForeignKey Tables in dependent order
    db.DropTable();
    db.DropTable();
    db.CreateTable();
    db.CreateTable();

    //DROP and CREATE tables without Foreign Keys in any order
    db.DropAndCreateTable();
    db.DropAndCreateTable();

    var savedLevel = new Level
    {
        Id = Guid.NewGuid(),
        Data = new byte[]{ 1, 2, 3, 4, 5 },
    };
    db.Insert(savedLevel);

    var player = new Player
    {
        Id = 1,
        FirstName = "North",
        LastName = "West",
        Email = "[email protected]",
        PhoneNumbers = new List
        {
            new Phone { Kind = PhoneKind.Mobile, Number = "123-555-5555"},
            new Phone { Kind = PhoneKind.Home,   Number = "555-555-5555", Ext = "123"},
        },
        GameItems = new List
        {
            new GameItem { Name = "WAND", Description = "Golden Wand of Odyssey"},
            new GameItem { Name = "STAFF", Description = "Staff of the Magi"},
        },
        Profile = new Profile
        {
            Username = "north",
            Role = PlayerRole.Leader,
            Region = Region.Australasia,
            HighScore = 100,
            GamesPlayed = 10,
            ProfileUrl = "https://www.gravatar.com/avatar/205e460b479e2e5b48aec07710c08d50.jpg",
            Meta = new Dictionary
            {
                {"Quote", "I am gamer"}
            },
        },
        SavedLevelId = savedLevel.Id,
    };
    db.Save(player, references: true);
}

This will add a record in all the above tables with all the Reference data properties automatically populated which we can quickly see by selecting the inserted Player record and all its referenced data by using OrmLite's Load APIs, e.g:

var dbPlayer = db.LoadSingleById(player.Id);

dbPlayer.PrintDump();

Which uses the Dump Utils to quickly display the populated data to the console:

{
    Id: 1,
    FirstName: North,
    LastName: West,
    Email: [email protected],
    PhoneNumbers: 
    [
        {
            Kind: Mobile,
            Number: 123-555-5555
        },
        {
            Kind: Home,
            Number: 555-555-5555,
            Ext: 123
        }
    ],
    GameItems: 
    [
        {
            Name: WAND,
            PlayerId: 1,
            Description: Golden Wand of Odyssey,
            DateAdded: 2018-01-17T07:53:45-05:00
        },
        {
            Name: STAFF,
            PlayerId: 1,
            Description: Staff of the Magi,
            DateAdded: 2018-01-17T07:53:45-05:00
        }
    ],
    Profile: 
    {
        Id: 1,
        Role: Leader,
        Region: Australasia,
        Username: north,
        HighScore: 100,
        GamesPlayed: 10,
        Energy: 0,
        ProfileUrl: "https://www.gravatar.com/avatar/205e460b479e2e5b48aec07710c08d50.jpg",
        Meta: 
        {
            Quote: I am gamer
        }
    },
    ProfileId: 1,
    SavedLevelId: 7690dfa4d31949ab9bce628c34d1c549,
    RowVersion: 2
}

Feel free to continue expirementing with this Example Live on Gistlyn.

Select APIs

If your SQL doesn't start with a SELECT statement, it is assumed a WHERE clause is being provided, e.g:

var tracks = db.Select("Artist = @artist AND Album = @album",
    new { artist = "Nirvana", album = "Heart Shaped Box" });

Which is equivalent to:

var tracks = db.Select("SELECT * FROM track WHERE Artist = @artist AND Album = @album", 
    new { artist = "Nirvana", album = "Heart Shaped Box" });

Use Sql* APIs for when you want to query custom SQL that is not a SELECT statement, e.g:

var tracks = db.SqlList("EXEC GetArtistTracks @artist, @album",
    new { artist = "Nirvana", album = "Heart Shaped Box" });

Select returns multiple records:

List tracks = db.Select()

Single returns a single record:

Track track = db.Single(x => x.RefId == refId)

Dictionary returns a Dictionary made from the first two columns:

Dictionary trackIdNamesMap = db.Dictionary(
    db.From().Select(x => new { x.Id, x.Name }))

Dictionary trackIdNamesMap = db.Dictionary(
    "select Id, Name from Track")

Lookup returns an Dictionary> made from the first two columns:

Dictionary> albumTrackNames = db.Lookup(
    db.From().Select(x => new { x.AlbumId, x.Name }))

Dictionary> albumTrackNames = db.Lookup(
    "select AlbumId, Name from Track")

Column returns a List of first column values:

List trackNames = db.Column(db.From().Select(x => x.Name))

List trackNames = db.Column("select Name from Track")

HashSet returns a HashSet of distinct first column values:

HashSet uniqueTrackNames = db.ColumnDistinct(
    db.From().Select(x => x.Name))

HashSet uniqueTrackNames = db.ColumnDistinct("select Name from Track")

Scalar returns a single scalar value:

var trackCount = db.Scalar(db.From().Select(Sql.Count("*")))

var trackCount = db.Scalar("select count(*) from Track")

Anonymous types passed into Where are treated like an AND filter:

var track3 = db.Where(new { AlbumName = "Throwing Copper", TrackNo = 3 })

SingleById(s), SelectById(s), etc provide strong-typed convenience methods to fetch by a Table's Id primary key field.

var track = db.SingleById(1);
var tracks = db.SelectByIds(new[]{ 1,2,3 });

Parametrized IN Values

OrmLite also supports providing collection of values which is automatically split into multiple DB parameters to simplify executing parameterized SQL with multiple IN Values, e.g:

var ids = new[]{ 1, 2, 3};
var results = db.Select("Id in (@ids)", new { ids });

var names = new List{ "foo", "bar", "qux" };
var results = db.SqlList("SELECT * FROM Table WHERE Name IN (@names)", new { names });
Lazy Queries
API's ending with Lazy yield an IEnumerable sequence letting you stream the results without having to map the entire resultset into a disconnected List of POCO's first, e.g:
var lazyQuery = db.SelectLazy("Age > @age", new { age = 40 });
// Iterate over a lazy sequence 
foreach (var person in lazyQuery) {
   //...  
}
Other examples
var topVIPs = db.WhereLazy(new { Age = 27 }).Where(p => IsVip(p)).Take(5)
Other Notes
 
   
All Insert, Update, and Delete methods take multiple params, while InsertAll, UpdateAll and DeleteAll take IEnumerables.
 
   
Save and SaveAll will Insert if no record with Id exists, otherwise it Updates.
 
   
Methods containing the word Each return an IEnumerable and are lazily loaded (i.e. non-buffered).
 
  
Features
Whilst OrmLite aims to provide a light-weight typed wrapper around SQL, it offers a number of convenient features that makes working with RDBMS's a clean and enjoyable experience:
Typed SqlExpression support for JOIN's
Starting with the most basic example you can simply specify the table you want to join with:
var q = db.From()
          .Join();

var dbCustomers = db.Select(q);
This query rougly maps to the following SQL:
SELECT Customer.* 
  FROM Customer 
       INNER JOIN 
       CustomerAddress ON (Customer.Id == CustomerAddress.CustomerId)
Just like before q is an instance of SqlExpression which is bounded to the base Customer type (and what any subsequent implicit API's apply to).
To better illustrate the above query, lets expand it to the equivalent explicit query:
SqlExpression q = db.From();
q.Join((cust,address) => cust.Id == address.CustomerId);

List dbCustomers = db.Select(q);
Reference Conventions
The above query implicitly joins together the Customer and CustomerAddress POCO's using the same {ParentType}Idproperty convention used in OrmLite's support for References, e.g:
class Customer {
    public int Id { get; set; }
    ...
}
class CustomerAddress {
    public int Id { get; set; }
    public int CustomerId { get; set; }  // Reference based on Property name convention
}
References based on matching alias names is also supported, e.g:
[Alias("LegacyCustomer")]
class Customer {
    public int Id { get; set; }
    ...
}
class CustomerAddress {
    public int Id { get; set; }

    [Alias("LegacyCustomerId")]             // Matches `LegacyCustomer` Alias
    public int RenamedCustomerId { get; set; }  // Reference based on Alias Convention
}
Self References
Self References are also supported for 1:1 relations where the Foreign Key can instead be on the parent table:
public class Customer
{
    ...
    public int CustomerAddressId { get; set; }

    [Reference]
    public CustomerAddress PrimaryAddress { get; set; }
}
Foreign Key and References Attributes
References that don't follow the above naming conventions can be declared explicitly using the [References] and [ForeignKey] attributes:
public class Customer
{
    [References(typeof(CustomerAddress))]
    public int PrimaryAddressId { get; set; }

    [Reference]
    public CustomerAddress PrimaryAddress { get; set; }
}
 
   
Reference Attributes take precedence over naming conventions
 
  
Multiple Self References
The example below shows a customer with multiple CustomerAddress references which are able to be matched with the {PropertyReference}Id naming convention, e.g:
public class Customer
{
    [AutoIncrement]
    public int Id { get; set; }
    public string Name { get; set; }

    [References(typeof(CustomerAddress))]
    public int? HomeAddressId { get; set; }

    [References(typeof(CustomerAddress))]
    public int? WorkAddressId { get; set; }

    [Reference]
    public CustomerAddress HomeAddress { get; set; }

    [Reference]
    public CustomerAddress WorkAddress { get; set; }
}
Once defined, it can be saved and loaded via OrmLite's normal Reference and Select API's, e.g:
var customer = new Customer
{
    Name = "The Customer",
    HomeAddress = new CustomerAddress {
        Address = "1 Home Street",
        Country = "US"
    },
    WorkAddress = new CustomerAddress {
        Address = "2 Work Road",
        Country = "UK"
    },
};

db.Save(customer, references:true);

var c = db.LoadSelect(x => x.Name == "The Customer");
c.WorkAddress.Address.Print(); // 2 Work Road

var ukAddress = db.Single(x => x.Country == "UK");
ukAddress.Address.Print();     // 2 Work Road
Implicit Reference Conventions are applied by default
The implicit relationship above allows you to use any of these equilvalent APIs to JOIN tables:
q.Join();
q.Join();
q.Join((cust,address) => cust.Id == address.CustomerId);
Selecting multiple columns across joined tables
The SelectMulti API lets you select from multiple joined tables into a typed tuple
var q = db.From()
    .Join()
    .Join()
    .Where(x => x.CreatedDate >= new DateTime(2016,01,01))
    .And(x => x.Country == "Australia");

var results = db.SelectMulti(q);

foreach (var tuple in results)
{
    Customer customer = tuple.Item1;
    CustomerAddress custAddress = tuple.Item2;
    Order custOrder = tuple.Item3;
}
Thanks to Micro ORM's lightweight abstractions over ADO.NET that maps to clean POCOs, we can also use OrmLite's embedded version of Dapper's QueryMultiple:
var q = db.From()
    .Join()
    .Join()
    .Select("*");

using (var multi = db.QueryMultiple(q.ToSelectStatement()))
{
    var results = multi.Read>(Tuple.Create).ToList();

    foreach (var tuple in results)
    {
        Customer customer = tuple.Item1;
        CustomerAddress custAddress = tuple.Item2;
        Order custOrder = tuple.Item3;
    }
}
Select data from multiple tables into a Custom POCO
Another implicit behaviour when selecting from a typed SqlExpression is that results are mapped to the Customer POCO. To change this default we just need to explicitly specify what POCO it should map to instead:
List customers = db.Select(
    db.From().Join());
Where FullCustomerInfo is any POCO that contains a combination of properties matching any of the joined tables in the query.
The above example is also equivalent to the shorthand db.Select() API:
var q = db.From()
          .Join();

var customers = db.Select(q);
Rules for how results are mapped is simply each property on FullCustomerInfo is mapped to the first matching property in any of the tables in the order they were added to the SqlExpression.
The mapping also includes a fallback for referencing fully-qualified names in the format: {TableName}{FieldName} allowing you to reference ambiguous fields, e.g:
 
   
CustomerId => "Customer"."Id"
 
   
OrderId => "Order"."Id"
 
   
CustomerName => "Customer"."Name"
 
   
OrderCost => "Order"."Cost"
 
  
Dynamic Result Sets
In addition to populating Typed POCOs, OrmLite has a number of flexible options for accessing dynamic resultsets with adhoc schemas:
C# 7 Value Tuples
The C# 7 Value Tuple support enables a terse, clean and typed API for accessing the Dynamic Result Sets returned when using a custom Select expression:
var query = db.From()
    .Join()
    .OrderBy(e => e.Id)
    .Select(
        (e, d) => new { e.Id, e.LastName, d.Name });
 
var results = db.Select<(int id, string lastName, string deptName)>(query);
 
var row = results[i];
$"row: ${row.id}, ${row.lastName}, ${row.deptName}".Print();
Full Custom SQL Example:
var results = db.SqlList<(int count, string min, string max, int sum)>(
    "SELECT COUNT(*), MIN(Word), MAX(Word), Sum(Total) FROM Table");
Partial Custom SQL Select Example:
var query = db.From
()
    .Select("COUNT(*), MIN(Word), MAX(Word), Sum(Total)");
 
var result = db.Single<(int count, string min, string max, int sum)>(query);
Same as above, but using Typed APIs:
var result = db.Single<(int count, string min, string max, int sum)>(
    db.From
()
        .Select(x => new {
            Count = Sql.Count("*"),
            Min = Sql.Min(x.Word),
            Max = Sql.Max(x.Word),
            Sum = Sql.Sum(x.Total)
        }));
There's also support for returning unstructured resultsets in List
(), to specify an AND condition on a Joined table 
   
Usage of Or, to specify an OR condition against 2 joined tables
 
   
  
More code examples of References and Joined tables are available in:
 
  
 
   
LoadReferencesTests.cs
 
   
LoadReferencesJoinTests.cs
 
  
 
  
Reference Support, POCO style
 
  
OrmLite lets you Store and Load related entities in separate tables using [Reference] attributes in primary tables in conjunction with {Parent}Id property convention in child tables, e.g:
 
  
public class Customer
{
    [AutoIncrement]
    public int Id { get; set; }
    public string Name { get; set; }

    [Reference] // Save in CustomerAddress table
    public CustomerAddress PrimaryAddress { get; set; }

    [Reference] // Save in Order table
    public List Orders { get; set; }
}

public class CustomerAddress
{
    [AutoIncrement]
    public int Id { get; set; }
    public int CustomerId { get; set; } //`{Parent}Id` convention to refer to Customer
    public string AddressLine1 { get; set; }
    public string AddressLine2 { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string Country { get; set; }
}

public class Order
{
    [AutoIncrement]
    public int Id { get; set; }
    public int CustomerId { get; set; } //`{Parent}Id` convention to refer to Customer
    public string LineItem { get; set; }
    public int Qty { get; set; }
    public decimal Cost { get; set; }
}
 
  
With the above structure you can save a POCO and all its entity references with db.Save(T,references:true), e.g:
 
  
var customer =  new Customer {
    Name = "Customer 1",
    PrimaryAddress = new CustomerAddress {
        AddressLine1 = "1 Australia Street",
        Country = "Australia"
    },
    Orders = new[] {
        new Order { LineItem = "Line 1", Qty = 1, Cost = 1.99m },
        new Order { LineItem = "Line 2", Qty = 2, Cost = 2.99m },
    }.ToList(),
};

db.Save(customer, references:true);
 
  
This saves the root customer POCO in the Customer table, its related PrimaryAddress in the CustomerAddress table and its 2 Orders in the Order table.
 
  
Querying POCO's with References
 
  
The Load* API's are used to automatically load a POCO and all it's child references, e.g:
 
  
var customer = db.LoadSingleById(customerId);
 
  
Using Typed SqlExpressions:
 
  
var customers = db.LoadSelect(x => x.Name == "Customer 1");
 
  
More examples available in LoadReferencesTests.cs
 
  
Unlike normal complex properties, references:
 
  
 
   
Doesn't persist as complex type blobs
 
   
Doesn't impact normal querying
 
   
Saves and loads references independently from itself
 
   
Are serializable with Text serializers (only populated are visible).
 
   
Loads related data only 1-reference-level deep
 
  
 
  
Basically they provides a better story when dealing with referential data that doesn't impact the POCO's ability to be used as DTO's.
 
  
Merge Disconnected POCO Result Sets
 
  
The Merge extension method can stitch disconnected POCO collections together as per their relationships defined in OrmLite's POCO References.
 
  
For example you can select a collection of Customers who've made an order with quantities of 10 or more and in a separate query select their filtered Orders and then merge the results of these 2 distinct queries together with:
 
  
//Select Customers who've had orders with Quantities of 10 or more
var q = db.From()
          .Join()
          .Where(o => o.Qty >= 10)
          .SelectDistinct();

List customers = db.Select(q);

//Select Orders with Quantities of 10 or more
List orders = db.Select(o => o.Qty >= 10);

customers.Merge(orders); // Merge disconnected Orders with their related Customers

customers.PrintDump();   // Print merged customers and orders datasets
 
  
Custom Load References
 
  
You can selectively specifying which references you want to load using the include parameter, e.g:
 
  
var customerWithAddress = db.LoadSingleById(customer.Id, include: new[] { "PrimaryAddress" });

//Alternative
var customerWithAddress = db.LoadSingleById(customer.Id, include: x => new { x.PrimaryAddress });
 
  
Custom Select with JOIN
 
  
You can specify SQL Aliases for ambiguous columns using anonymous properties, e.g:
 
  
var q = db.From()
    .Join()
    .Select((a, b) => new { a, JoinId = b.Id, JoinName = b.Name }); 
  
Which is roughly equivalent to:
 
  
SELECT a.*, b.Id AS JoinId, b.Name AS JoinName
 
  
Where it selects all columns from the primary Table as well as Id and Name columns from JoinedTable, returning them in the JoinId and JoinName custom aliases.
 
  
Nested JOIN Table Expressions
 
  
You can also query POCO References on JOIN tables, e.g:
 
  
var q = db.From()
    .Join()
    .Join()
    .Where(x => !x.IsValid.HasValue && 
        x.Join1.IsValid &&
        x.Join1.Join2.Name == theName &&
        x.Join1.Join2.IntValue == intValue)
    .GroupBy(x => x.Join1.Join2.IntValue)
    .Having(x => Sql.Max(x.Join1.Join2.IntValue) != 10)
    .Select(x => x.Join1.Join2.IntValue); 
  
JOIN aliases
 
  
You can specify join aliases when joining same table multiple times together to differentiate from any ambiguous columns, e.g:
 
  
var q = db.From()
    .LeftJoin((s,c) => s.SellerId == c.Id, db.JoinAlias("seller"))
    .LeftJoin((s,c) => s.BuyerId == c.Id, db.JoinAlias("buyer"))
    .Select((s,c) => new {
        s,
        BuyerFirstName = Sql.JoinAlias(c.FirstName, "buyer"),
        BuyerLastName = Sql.JoinAlias(c.LastName, "buyer"),
        SellerFirstName = Sql.JoinAlias(c.FirstName, "seller"),
        SellerLastName = Sql.JoinAlias(c.LastName, "seller"),
    });
 
  
Unique Constraints
 
  
In addition to creating an Index with unique constraints using [Index(Unique=true)] you can now use [Unique] to enforce a single column should only contain unique values or annotate the class with [UniqueConstraint] to specify a composite unique constraint, e.g:
 
  
[UniqueConstraint(nameof(PartialUnique1), nameof(PartialUnique2), nameof(PartialUnique3))]
public class UniqueTest
{
    [AutoIncrement]
    public int Id { get; set; }

    [Unique]
    public string UniqueField { get; set; }

    public string PartialUnique1 { get; set; }
    public string PartialUnique2 { get; set; }
    public string PartialUnique3 { get; set; }
}
 
  
Auto populated Guid Ids
 
  
Support for Auto populating Guid Primary Keys was also added in this release with the new [AutoId] attribute, e.g:
 
  
public class Table
{
    [AutoId]
    public Guid Id { get; set; }
}
 
  
In SQL Server it will populate Id primary key with newid(), in PostgreSQL it uses uuid_generate_v4() which requires installing the the uuid-ossp extension by running the SQL below on each PostgreSQL RDBMS it's used on:
 
  
CREATE EXTENSION IF NOT EXISTS "uuid-ossp"
 
  
For all other RDBMS's OrmLite will populate the Id with Guid.NewGuid(). In all RDBMS's it will populate the Id property on db.Insert() or db.Save() with the new value, e.g:
 
  
var row = new Table { ... };
db.Insert(row);
row.Id //= Auto populated with new Guid
 
  
SQL Server 2012 Sequences
 
  
The [Sequence] attribute can be used as an alternative to [AutoIncrement] for inserting rows with an auto incrementing integer value populated by SQL Server, but instead of needing an IDENTITY column it can populate a normal INT column from a user-defined Sequence, e.g:
 
  
public class SequenceTest
{
    [Sequence("Seq_SequenceTest_Id"), ReturnOnInsert]
    public int Id { get; set; }

    public string Name { get; set; }
    public string UserName { get; set; }
    public string Email { get; set; }

    [Sequence("Seq_Counter")]
    public int Counter { get; set; }
}

var user = new SequenceTest { Name = "me", Email = "[email protected]" };
db.Insert(user);

user.Id //= Populated by next value in "Seq_SequenceTest_Id" SQL Server Sequence
 
  
The new [ReturnOnInsert] attribute tells OrmLite which columns to return the values of, in this case it returns the new Sequence value the row was inserted with. Sequences offer more flexibility than IDENTITY columns where you can use multiple sequences in a table or have the same sequence shared across multiple tables.
 
  
When creating tables, OrmLite will also create any missing Sequences automatically so you can continue to have reproducible tests and consistent Startups states that's unreliant on external state. But it doesn't drop sequences when OrmLite drops the table as they could have other external dependents.
 
  
To be able to use the new sequence support you'll need to use an SQL Server dialect greater than SQL Server 2012+, e.g:
 
  
var dbFactory = new OrmLiteConnectionFactory(connString, SqlServer2012Dialect.Provider);
 
  
SQL Server Table Hints
 
  
Using the same JOIN Filter feature OrmLite also lets you add SQL Server Hints on JOIN Table expressions, e.g:
 
  
var q = db.From()
    .Join((c, t) => c.CarId == t.CarId, SqlServerTableHint.ReadUncommitted);
 
  
Which emits the appropriate SQL Server hints:
 
  
SELECT "Car"."CarId", "CarType"."CarTypeName" 
FROM "Car" INNER JOIN "CarType" WITH (READUNCOMMITTED) ON ("Car"."CarId" = "CarType"."CarId")
 
  
Custom SqlExpression Filter
 
  
The generated SQL from a Typed SqlExpression can also be customized using .WithSqlFilter(), e.g:
 
  
var q = db.From()
    .Where(x => x.Age == 27)
    .WithSqlFilter(sql => sql + " option (recompile)");

var q = db.From()
    .Where(x => x.Age == 27)
    .WithSqlFilter(sql => sql + " WITH UPDLOCK");

var results = db.Select(q); 
  
Nested Typed Sub SqlExpressions
 
  
The Sql.In() API supports nesting and combining of multiple Typed SQL Expressions together in a single SQL Query, e.g:
 
  
var usaCustomerIds = db.From(c => c.Country == "USA").Select(c => c.Id);
var usaCustomerOrders = db.Select(db.From()
    .Where(x => Sql.In(x.CustomerId, usaCustomerIds)));
 
  
Optimistic Concurrency
 
  
Optimistic concurrency can be added to any table by adding the ulong RowVersion { get; set; } property, e.g:
 
  
public class Poco
{
    ...
    public ulong RowVersion { get; set; }
}
 
  
RowVersion is implemented efficiently in all major RDBMS's, i.e:
 
  
 
   
Uses rowversion datatype in SqlServer
 
   
Uses PostgreSql's xmin system column (no column on table required)
 
   
Uses UPDATE triggers on MySql, Sqlite and Oracle whose lifetime is attached to Create/Drop tables APIs
 
  
 
  
Despite their differing implementations each provider works the same way where the RowVersion property is populated when the record is selected and only updates the record if the RowVersion matches with what's in the database, e.g:
 
  
var rowId = db.Insert(new Poco { Text = "Text" }, selectIdentity:true);

var row = db.SingleById(rowId);
row.Text += " Updated";
db.Update(row); //success!

row.Text += "Attempting to update stale record";

//Can't update stale record
Assert.Throws(() =>
    db.Update(row));

//Can update latest version
var updatedRow = db.SingleById(rowId);  // fresh version
updatedRow.Text += "Update Success!";
db.Update(updatedRow);

updatedRow = db.SingleById(rowId);
db.Delete(updatedRow);                        // can delete fresh version
 
  
Optimistic concurrency is only verified on API's that update or delete an entire entity, i.e. it's not enforced in partial updates. There's also an Alternative API available for DELETE's:
 
  
db.DeleteById(id:updatedRow.Id, rowversion:updatedRow.RowVersion)
 
  
RowVersion Byte Array
 
  
To improve reuse of OrmLite's Data Models in Dapper, OrmLite also supports byte[] RowVersion which lets you use OrmLite Data Models with byte[] RowVersion properties in Dapper queries.
 
  
Conflict Resolution using commandFilter
 
  
An optional Func commandFilter is available in all INSERT and UPDATE APIs to allow customization and inspection of the populated IDbCommand before it's run. This feature is utilized in the Conflict Resolution Extension methodswhere you can specify the conflict resolution strategy when a Primary Key or Unique constraint violation occurs:
 
  
db.InsertAll(rows, dbCmd => dbCmd.OnConflictIgnore());

//Equivalent to: 
db.InsertAll(rows, dbCmd => dbCmd.OnConflict(ConflictResolution.Ignore));
 
  
In this case it will ignore any conflicts that occurs and continue inserting the remaining rows in SQLite, MySql and PostgreSQL, whilst in SQL Server it's a NOOP.
 
  
SQLite offers additional fine-grained behavior that can be specified for when a conflict occurs:
 
  
 
   
ROLLBACK
 
   
ABORT
 
   
FAIL
 
   
IGNORE
 
   
REPLACE
 
  
 
  
Modify Custom Schema
 
  
OrmLite provides Typed APIs for modifying Table Schemas that makes it easy to inspect the state of an RDBMS Table which can be used to determine what modifications you want on it, e.g:
 
  
class Poco 
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Ssn { get; set; }
}

db.DropTable();
db.TableExists(); //= false

db.CreateTable(); 
db.TableExists(); //= true

db.ColumnExists(x => x.Ssn); //= true
db.DropColumn(x => x.Ssn);
db.ColumnExists(x => x.Ssn); //= false
 
  
In a future version of your Table POCO you can use ColumnExists to detect which columns haven't been added yet, then use AddColumn to add it, e.g:
 
  
class Poco 
{
    public int Id { get; set; }
    public string Name { get; set; }

    [Default(0)]
    public int Age { get; set; }
}

if (!db.ColumnExists(x => x.Age)) //= false
    db.AddColumn(x => x.Age);

db.ColumnExists(x => x.Age); //= true
 
  
Modify Schema APIs
 
  
Additional Modify Schema APIs available in OrmLite include:
 
  
 
   
AlterTable
 
   
AddColumn
 
   
AlterColumn
 
   
ChangeColumnName
 
   
DropColumn
 
   
AddForeignKey
 
   
DropForeignKey
 
   
CreateIndex
 
   
DropIndex
 
  
 
  
Typed Sql.Cast() SQL Modifier
 
  
The Sql.Cast() provides a cross-database abstraction for casting columns or expressions in SQL queries, e.g:
 
  
db.Insert(new SqlTest { Value = 123.456 });

var results = db.Select<(int id, string text)>(db.From()
    .Select(x => new {
        x.Id,
        text = Sql.Cast(x.Id, Sql.VARCHAR) + " : " + Sql.Cast(x.Value, Sql.VARCHAR) + " : " 
             + Sql.Cast("1 + 2", Sql.VARCHAR) + " string"
    }));

results[0].text //= 1 : 123.456 : 3 string
 
  
Typed Column and Table APIs
 
  
You can use the Column and Table() methods to resolve the quoted names of a Column or Table within SQL Fragments (taking into account any configured aliases or naming strategies).
 
  
Usage Example of the new APIs inside a CustomJoin() expression used to join on a custom SELECT expression:
 
  
q.CustomJoin($"LEFT JOIN (SELECT {q.Column(x => x.Id)} ...")
q.CustomJoin($"LEFT JOIN (SELECT {q.Column(nameof(Job.Id))} ...")

q.CustomJoin($"LEFT JOIN (SELECT {q.Column(x => x.Id, tablePrefix:true)} ...")
//Equivalent to:
q.CustomJoin($"LEFT JOIN (SELECT {q.Table()}.{q.Column(x => x.Id)} ...")

q.Select($"{q.Column(x => x.Id)} as JobId, {q.Column(x => x.Id)} as TaskId")
//Equivalent to:
q.Select((j,t) => new { JobId = j.Id, TaskId = t.Id })
 
  
DB Parameter API's
 
  
To enable even finer-grained control of parameterized queries we've added new overloads that take a collection of IDbDataParameter's:
 
  
List Select(string sql, IEnumerable sqlParams)
T Single(string sql, IEnumerable sqlParams)
T Scalar(string sql, IEnumerable sqlParams)
List Column(string sql, IEnumerable sqlParams)
IEnumerable ColumnLazy(string sql, IEnumerable sqlParams)
HashSet ColumnDistinct(string sql, IEnumerable sqlParams)
Dictionary> Lookup(string sql, IEnumerable sqlParams)
List SqlList(string sql, IEnumerable sqlParams)
List SqlColumn(string sql, IEnumerable sqlParams)
T SqlScalar(string sql, IEnumerable sqlParams)
 
  
 
   
Including Async equivalents for each of the above Sync API's.
 
  
 
  
The new API's let you execute parameterized SQL with finer-grained control over the IDbDataParameter used, e.g:
 
  
IDbDataParameter pAge = db.CreateParam("age", 40, dbType:DbType.Int16);
db.Select("SELECT * FROM Person WHERE Age > @pAge", new[] { pAge });
 
  
The new CreateParam() extension method above is a useful helper for creating custom IDbDataParameter's.
 
  
Customize null values
 
  
The new OrmLiteConfig.OnDbNullFilter lets you to replace DBNull values with a custom value, so you could convert all null strings to be populated with "NULL" using:
 
  
OrmLiteConfig.OnDbNullFilter = fieldDef => 
    fieldDef.FieldType == typeof(string)
        ? "NULL"
        : null;
 
  
Logging an Introspection
 
  
One way to see what queries OrmLite generates is to enable a debug enabled logger, e.g:
 
  
LogManager.LogFactory = new ConsoleLogFactory(debugEnabled:true);
 
  
Where it will log the generated SQL and Params OrmLite executes to the Console.
 
  
BeforeExecFilter and AfterExecFilter filters
 
  
An alternative to debug logging which can easily get lost in the noisy stream of other debug messages is to use the BeforeExecFilter and AfterExecFilter filters where you can inspect executed commands with a custom lambda expression before and after each query is executed. So if one of your a queries are failing you can put a breakpoint in BeforeExecFilter to inspect the populated IDbCommand object before it's executed or use the .GetDebugString() extension method for an easy way to print the Generated SQL and DB Params to the Console:
 
  
OrmLiteConfig.BeforeExecFilter = dbCmd => Console.WriteLine(dbCmd.GetDebugString());

//OrmLiteConfig.AfterExecFilter = dbCmd => Console.WriteLine(dbCmd.GetDebugString());
 
  
Exec, Result and String Filters
 
  
OrmLite's core Exec filters makes it possible to inject your own behavior, tracing, profiling, etc.
 
  
It's useful in situations like wanting to use SqlServer in production but use an in-memory Sqlite database in tests and being able to emulate any missing SQL Server Stored Procedures in code:
 
  
public class MockStoredProcExecFilter : OrmLiteExecFilter
{
    public override T Exec(IDbConnection dbConn, Func filter)
    {
        try
        {
            return base.Exec(dbConn, filter);
        }
        catch (Exception ex)
        {
            if (dbConn.GetLastSql() == "exec sp_name @firstName, @age")
                return (T)(object)new Person { FirstName = "Mocked" };
            throw;
        }
    }
}

OrmLiteConfig.ExecFilter = new MockStoredProcExecFilter();

using (var db = OpenDbConnection())
{
    var person = db.SqlScalar("exec sp_name @firstName, @age",
        new { firstName = "aName", age = 1 });

    person.FirstName.Print(); //Mocked
}
 
  
CaptureSqlFilter
 
  
Results filters makes it trivial to implement the CaptureSqlFilter which allows you to capture SQL Statements without running them. CaptureSqlFilter is just a simple Results Filter which can be used to quickly found out what SQL your DB calls generate by surrounding DB access in a using scope, e.g:
 
  
using (var captured = new CaptureSqlFilter())
using (var db = OpenDbConnection())
{
    db.Where(new { Age = 27 });

    captured.SqlStatements[0].PrintDump();
}
 
  
Emits the Executed SQL along with any DB Parameters:
 
  
{
    Sql: "SELECT ""Id"", ""FirstName"", ""LastName"", ""Age"" FROM ""Person"" WHERE ""Age"" = @Age",
    Parameters: 
    {
        Age: 27
    }
}
 
  
Replay Exec Filter
 
  
Or if you want to do things like executing each operation multiple times, e.g:
 
  
public class ReplayOrmLiteExecFilter : OrmLiteExecFilter
{
    public int ReplayTimes { get; set; }

    public override T Exec(IDbConnection dbConn, Func filter)
    {
        var holdProvider = OrmLiteConfig.DialectProvider;
        var dbCmd = CreateCommand(dbConn);
        try
        {
            var ret = default(T);
            for (var i = 0; i < ReplayTimes; i++)
            {
                ret = filter(dbCmd);
            }
            return ret;
        }
        finally
        {
            DisposeCommand(dbCmd);
            OrmLiteConfig.DialectProvider = holdProvider;
        }
    }
}

OrmLiteConfig.ExecFilter = new ReplayOrmLiteExecFilter { ReplayTimes = 3 };

using (var db = OpenDbConnection())
{
    db.DropAndCreateTable();
    db.Insert(new PocoTable { Name = "Multiplicity" });

    var rowsInserted = db.Count(x => x.Name == "Multiplicity"); //3
}
 
  
Mockable extension methods
 
  
The Result Filters also lets you easily mock results and avoid hitting the database, typically useful in Unit Testing Services to mock OrmLite API's directly instead of using a repository, e.g:
 
  
using (new OrmLiteResultsFilter {
    PrintSql = true,
    SingleResult = new Person { 
      Id = 1, FirstName = "Mocked", LastName = "Person", Age = 100 
    },
})
{
    db.Single(x => x.Age == 42).FirstName // Mocked
    db.Single(db.From().Where(x => x.Age == 42)).FirstName // Mocked
    db.Single(new { Age = 42 }).FirstName // Mocked
    db.Single("Age = @age", new { age = 42 }).FirstName // Mocked
}
 
  
More examples showing how to mock different API's including support for nesting available in MockAllApiTests.cs
 
  
String Filter
 
  
There's also a specific filter for strings available which allows you to apply custom sanitization on String fields, e.g. you can ensure all strings are right trimmed with:
 
  
OrmLiteConfig.StringFilter = s => s.TrimEnd();

db.Insert(new Poco { Name = "Value with trailing   " });
db.Select().First().Name // "Value with trailing"
 
  
Pluggable Complex Type Serializers
 
  
Pluggable serialization lets you specify different serialization strategies of Complex Types for each available RDBMS provider, e.g:
 
  
//ServiceStack's JSON and JSV Format
SqliteDialect.Provider.StringSerializer = new JsvStringSerializer();       
PostgreSqlDialect.Provider.StringSerializer = new JsonStringSerializer();
//.NET's XML and JSON DataContract serializers
SqlServerDialect.Provider.StringSerializer = new DataContractSerializer();
MySqlDialect.Provider.StringSerializer = new JsonDataContractSerializer();
//.NET XmlSerializer
OracleDialect.Provider.StringSerializer = new XmlSerializableSerializer();
 
  
You can also provide a custom serialization strategy by implementing IStringSerializer.
 
  
By default all dialects use the existing JsvStringSerializer, except for PostgreSQL which due to its built-in support for JSON, uses the JSON format by default.
 
  
Global Insert / Update Filters
 
  
Similar to interceptors in some heavy ORM's, Insert and Update filters get fired just before any INSERT or UPDATE operation using OrmLite's typed API's (i.e. not dynamic SQL or partial updates using anon types). This functionality can be used for easily auto-maintaining Audit information for your POCO data models, e.g:
 
  
public interface IAudit 
{
    DateTime CreatedDate { get; set; }
    DateTime ModifiedDate { get; set; }
    string ModifiedBy { get; set; }
}

OrmLiteConfig.InsertFilter = (dbCmd, row) => {
    if (row is IAudit auditRow)
        auditRow.CreatedDate = auditRow.ModifiedDate = DateTime.UtcNow;
};

OrmLiteConfig.UpdateFilter = (dbCmd, row) => {
    if (row is IAudit auditRow)
        auditRow.ModifiedDate = DateTime.UtcNow;
};
 
  
Which will ensure that the CreatedDate and ModifiedDate fields are populated on every insert and update.
 
  
Validation Example
 
  
The filters can also be used for validation where throwing an exception will prevent the operation and bubble the exception, e.g:
 
  
OrmLiteConfig.InsertFilter = OrmLiteConfig.UpdateFilter = (dbCmd, row) => {
    if (row is IAudit auditRow && auditRow.ModifiedBy == null)
        throw new ArgumentNullException("ModifiedBy");
};

try
{
    db.Insert(new AuditTable());
}
catch (ArgumentNullException) {
   //throws ArgumentNullException
}

db.Insert(new AuditTable { ModifiedBy = "Me!" }); //succeeds
 
  
Custom SQL Customizations
 
  
A number of new hooks are available to provide more flexibility when creating and dropping your RDBMS tables.
 
  
CustomSelect Attribute
 
  
The new [CustomSelect] can be used to define properties you want populated from a Custom SQL Function or Expression instead of a normal persisted column, e.g:
 
  
public class Block
{
    public int Id { get; set; }
    public int Width { get; set; }
    public int Height { get; set; }

    [CustomSelect("Width * Height")]
    public int Area { get; set; }

    [Default(OrmLiteVariables.SystemUtc)]
    public DateTime CreatedDate { get; set; }

    [CustomSelect("FORMAT(CreatedDate, 'yyyy-MM-dd')")]
    public string DateFormat { get; set; }
}

db.Insert(new Block { Id = 1, Width = 10, Height = 5 });

var block = db.SingleById(1);

block.Area.Print(); //= 50

block.DateFormat.Print(); //= 2016-06-08 (SQL Server)
 
  
Order by dynamic expressions
 
  
The [CustomSelect] attribute can be used to populate a property with a dynamic SQL Expression instead of an existing column, e.g:
 
  
public class FeatureRequest
{
    public int Id { get; set; }
    public int Up { get; set; }
    public int Down { get; set; }

    [CustomSelect("1 + Up - Down")]
    public int Points { get; set; }
}
 
  
You can also order by the SQL Expression by referencing the property as you would a normal column. By extension this feature now also works in AutoQuery where you can select it in a partial result set and order the results by using its property name, e.g:
 
  
/features?fields=id,points&orderBy=points
 
  
Custom SQL Fragments
 
  
The Sql.Custom() API lets you use raw SQL Fragments in Custom .Select() expressions, e.g:
 
  
var q = db.From()
    .Select(x => new {
        FirstName = x.FirstName,
        LastName = x.LastName,
        Initials = Sql.Custom("CONCAT(LEFT(FirstName,1), LEFT(LastName,1))")
    }); 
  
Custom Field Declarations
 
  
The [CustomField] attribute can be used for specifying custom field declarations in the generated Create table DDL statements, e.g:
 
  
public class PocoTable
{
    public int Id { get; set; }

    [CustomField("CHAR(20)")]
    public string CharColumn { get; set; }

    [CustomField("DECIMAL(18,4)")]
    public decimal? DecimalColumn { get; set; }

    [CustomField(OrmLiteVariables.MaxText)]        //= {MAX_TEXT}
    public string MaxText { get; set; }

    [CustomField(OrmLiteVariables.MaxTextUnicode)] //= {NMAX_TEXT}
    public string MaxUnicodeText { get; set; }
}

db.CreateTable(); 
 
  
Generates and executes the following SQL in SQL Server:
 
  
CREATE TABLE "PocoTable" 
(
  "Id" INTEGER PRIMARY KEY, 
  "CharColumn" CHAR(20) NULL, 
  "DecimalColumn" DECIMAL(18,4) NULL, 
  "MaxText" VARCHAR(MAX) NULL, 
  "MaxUnicodeText" NVARCHAR(MAX) NULL 
); 
 
  
 
   
OrmLite replaces any variable placeholders with the value in each RDBMS DialectProvider's Variables Dictionary.
 
  
 
  
Pre / Post Custom SQL Hooks when Creating and Dropping tables
 
  
Pre / Post Custom SQL Hooks allow you to inject custom SQL before and after tables are created or dropped, e.g:
 
  
[PostCreateTable("INSERT INTO TableWithSeedData (Name) VALUES ('Foo');" +
                 "INSERT INTO TableWithSeedData (Name) VALUES ('Bar');")]
public class TableWithSeedData
{
    [AutoIncrement]
    public int Id { get; set; }
    public string Name { get; set; }
}
 
  
Which like other ServiceStack attributes, can also be added dynamically, e.g:
 
  
typeof(TableWithSeedData)
    .AddAttributes(new PostCreateTableAttribute(
        "INSERT INTO TableWithSeedData (Name) VALUES ('Foo');" +
        "INSERT INTO TableWithSeedData (Name) VALUES ('Bar');"));
 
  
Custom SQL Hooks also allow executing custom SQL before and after a table has been created or dropped, i.e:
 
  
[PreCreateTable(runSqlBeforeTableCreated)]
[PostCreateTable(runSqlAfterTableCreated)]
[PreDropTable(runSqlBeforeTableDropped)]
[PostDropTable(runSqlAfterTableDropped)]
public class Table {}
 
  
Untyped API support
 
  
The IUntypedApi interface is useful for when you only have access to a late-bound object runtime type which is accessible via db.CreateTypedApi, e.g:
 
  
public class BaseClass
{
    public int Id { get; set; }
}

public class Target : BaseClass
{
    public string Name { get; set; }
}

var row = (BaseClass)new Target { Id = 1, Name = "Foo" };

var useType = row.GetType();
var typedApi = db.CreateTypedApi(useType);

db.DropAndCreateTables(useType);

typedApi.Save(row);

var typedRow = db.SingleById(1);
typedRow.Name //= Foo

var updateRow = (BaseClass)new Target { Id = 1, Name = "Bar" };

typedApi.Update(updateRow);

typedRow = db.SingleById(1);
typedRow.Name //= Bar

typedApi.Delete(typedRow, new { Id = 1 });

typedRow = db.SingleById(1); //= null
 
  
T4 Template Support
 
  
OrmLite's T4 Template are useful in database-first development or when wanting to use OrmLite with an existing RDBMS by automatically generating POCO's and strong-typed wrappers for executing stored procedures.
 
  
OrmLite's T4 support can be added via NuGet with:
 
  
PM> Install-Package ServiceStack.OrmLite.T4
 
  
Typed SqlExpressions with Custom SQL APIs
 
  
OrmLite's Expression support satisfies the most common RDBMS queries with a strong-typed API. For more complex queries you can easily fall back to raw SQL where the Custom SQL API's let you to map custom SqlExpressions into different responses:
 
  
var q = db.From()
          .Where(x => x.Age < 50)
          .Select("*");
List results = db.SqlList(q);

List results = db.SqlList(
    "SELECT * FROM Person WHERE Age < @age", new { age=50});

List results = db.SqlColumn(db.From().Select(x => x.LastName));
List results = db.SqlColumn("SELECT LastName FROM Person");

HashSet results = db.ColumnDistinct(db.From().Select(x => x.Age));
HashSet results = db.ColumnDistinct("SELECT Age FROM Person");

var q = db.From()
          .Where(x => x.Age < 50)
          .Select(Sql.Count("*"));
int result = db.SqlScalar(q);
int result = db.SqlScalar("SELCT COUNT(*) FROM Person WHERE Age < 50");
 
  
Custom Insert and Updates
 
  
Db.ExecuteSql("INSERT INTO page_stats (ref_id, fav_count) VALUES (@refId, @favCount)",
              new { refId, favCount })

//Async:
Db.ExecuteSqlAsync("UPDATE page_stats SET view_count = view_count + 1 WHERE id = @id", new { id })
 
  
Stored Procedures using Custom Raw SQL API's
 
  
The Raw SQL API's provide a convenient way for mapping results of any Custom SQL like executing Stored Procedures:
 
  
List results = db.SqlList("EXEC GetAnalyticsForWeek 1");
List results = db.SqlList(
    "EXEC GetAnalyticsForWeek @weekNo", new { weekNo = 1 });

List results = db.SqlList("EXEC GetTotalsForWeek 1");
List results = db.SqlList(
    "EXEC GetTotalsForWeek @weekNo", new { weekNo = 1 });

int result = db.SqlScalar("SELECT 10");
 
  
Stored Procedures with output params
 
  
The SqlProc API provides even greater customization by letting you modify the underlying ADO.NET Stored Procedure call by returning a prepared IDbCommand allowing for advanced customization like setting and retriving OUT parameters, e.g:
 
  
string spSql = @"DROP PROCEDURE IF EXISTS spSearchLetters;
    CREATE PROCEDURE spSearchLetters (IN pLetter varchar(10), OUT pTotal int)
    BEGIN
        SELECT COUNT(*) FROM LetterFrequency WHERE Letter = pLetter INTO pTotal;
        SELECT * FROM LetterFrequency WHERE Letter = pLetter;
    END";

db.ExecuteSql(spSql);

using (var cmd = db.SqlProc("spSearchLetters", new { pLetter = "C" }))
{
    var pTotal = cmd.AddParam("pTotal", direction: ParameterDirection.Output);

    var results = cmd.ConvertToList();
    var total = pTotal.Value;
}
 
  
An alternative approach is to use SqlList which lets you use a filter to customize a Stored Procedure or any other command type, e.g:
 
  
IDbDataParameter pTotal = null;
var results = db.SqlList("spSearchLetters", cmd => {
        cmd.CommandType = CommandType.StoredProcedure;
        cmd.AddParam("pLetter", "C");
        pTotal = cmd.AddParam("pTotal", direction: ParameterDirection.Output);
    });
var total = pTotal.Value;
 
  
More examples can be found in SqlServerProviderTests.
 
  
Foreign Key attribute for referential actions on Update/Deletes
 
  
Creating a foreign key in OrmLite can be done by adding [References(typeof(ForeignKeyTable))] on the relation property, which will result in OrmLite creating the Foreign Key relationship when it creates the DB table with db.CreateTable.
 
  
Additional fine-grain options and behaviour are available in the [ForeignKey] attribute which will let you specify the desired behaviour when deleting or updating related rows in Foreign Key tables.
 
  
An example of a table with the different available options:
 
  
public class TableWithAllCascadeOptions
{
	[AutoIncrement] public int Id { get; set; }
	
	[References(typeof(ForeignKeyTable1))]
	public int SimpleForeignKey { get; set; }
	
	[ForeignKey(typeof(ForeignKeyTable2), OnDelete = "CASCADE", OnUpdate = "CASCADE")]
	public int? CascadeOnUpdateOrDelete { get; set; }
	
	[ForeignKey(typeof(ForeignKeyTable3), OnDelete = "NO ACTION")]
	public int? NoActionOnCascade { get; set; }
	
	[Default(typeof(int), "17")]
	[ForeignKey(typeof(ForeignKeyTable4), OnDelete = "SET DEFAULT")]
	public int SetToDefaultValueOnDelete { get; set; }
	
	[ForeignKey(typeof(ForeignKeyTable5), OnDelete = "SET NULL")]
	public int? SetToNullOnDelete { get; set; }
}
 
  
System Variables and Default Values
 
  
To provide richer support for non-standard default values, each RDBMS Dialect Provider contains aOrmLiteDialectProvider.Variables placeholder dictionary for storing common, but non-standard RDBMS functionality. We can use this to declaratively define non-standard default values that works across all supported RDBMS's like automatically populating a column with the RDBMS UTC Date when Inserted with a default(T) Value:
 
  
public class Poco
{
    [Default(OrmLiteVariables.SystemUtc)]  //= {SYSTEM_UTC}
    public DateTime CreatedTimeUtc { get; set; }
}
 
  
OrmLite variables need to be surrounded with {} braces to identify that it's a placeholder variable, e.g {SYSTEM_UTC}.
 
  
The ForeignKeyTests show the resulting behaviour with each of these configurations in more detail.
 
  
 
   
Note: Only supported on RDBMS's with foreign key/referential action support, e.g. Sql Server, PostgreSQL, MySQL. Otherwise they're ignored.
 
  
 
  
Multi nested database connections
 
  
We now support multiple nested database connections so you can now trivially use OrmLite to access multiple databases on different connections. The OrmLiteConnectionFactory class has been extended to support named connections which allows you to conveniently define all your db connections when you register it in your IOC and access them with the named property when you use them.
 
  
A popular way of scaling RDBMS's is to create a Master / Shard setup where datasets for queries that span entire system are kept in the master database, whilst context-specific related data can be kept together in an isolated shard. This feature makes it trivial to maintain multiple separate db shards with a master database in a different RDBMS.
 
  
Here's an (entire source code) sample of the code needed to define, and populate a Master/Shard setup. Sqlite can create DB shards on the fly so only the blank SqlServer master database needed to be created out-of-band:
 
  
Sharding 1000 Robots into 10 Sqlite DB shards - referencing each in a Master SqlServer RDBMS
 
  
public class MasterRecord {
    public Guid Id { get; set; }
    public int RobotId { get; set; }
    public string RobotName { get; set; }
    public DateTime? LastActivated { get; set; }
}

public class Robot {
    public int Id { get; set; }
    public string Name { get; set; }
    public bool IsActivated { get; set; }
    public long CellCount { get; set; }
    public DateTime CreatedDate { get; set; }
}

const int NoOfShards = 10;
const int NoOfRobots = 1000;

var dbFactory = new OrmLiteConnectionFactory(
    "Data Source=host;Initial Catalog=RobotsMaster;Integrated Security=SSPI",  //Connection String
    SqlServerDialect.Provider); 

dbFactory.Run(db => db.CreateTable(overwrite:false));

NoOfShards.Times(i => {
    var namedShard = "robots-shard" + i;
    dbFactory.RegisterConnection(namedShard, 
        $"~/App_Data/{shardId}.sqlite".MapAbsolutePath(),                //Connection String
        SqliteDialect.Provider);
	
	dbFactory.OpenDbConnection(namedShard).Run(db => db.CreateTable(overwrite:false));
});

var newRobots = NoOfRobots.Times(i => //Create 1000 Robots
    new Robot { Id=i, Name="R2D"+i, CreatedDate=DateTime.UtcNow, CellCount=DateTime.Now.ToUnixTimeMs() % 100000 });

foreach (var newRobot in newRobots) 
{
    using (IDbConnection db = dbFactory.OpenDbConnection()) //Open Connection to Master DB 
    {
        db.Insert(new MasterRecord { Id = Guid.NewGuid(), RobotId = newRobot.Id, RobotName = newRobot.Name });
        using (IDbConnection robotShard = dbFactory.OpenDbConnection("robots-shard"+newRobot.Id % NoOfShards)) //Shard
        {
            robotShard.Insert(newRobot);
        }
    }
}
 
  
Using the SQLite Manager Firefox extension we can peek at one of the created shards to see 100 Robots in each shard. This is the dump of robots-shard0.sqlite:
 
  
 
  
As expected each shard has every 10th robot inside.
 
  
Code-first Customer & Order example with complex types on POCO as text blobs
 
  
Below is a complete stand-alone example. No other config or classes is required for it to run. It's also available as a stand-alone unit test.
 
  
public enum PhoneType {
    Home,
    Work,
    Mobile,
}

public enum AddressType {
    Home,
    Work,
    Other,
}

public class Address {
    public string Line1 { get; set; }
    public string Line2 { get; set; }
    public string ZipCode { get; set; }
    public string State { get; set; }
    public string City { get; set; }
    public string Country { get; set; }
}

public class Customer {
    public Customer() {
        this.PhoneNumbers = new Dictionary();
        this.Addresses = new Dictionary();
    }

    [AutoIncrement] // Creates Auto primary key
    public int Id { get; set; }
    
    public string FirstName { get; set; }
    public string LastName { get; set; }
    
    [Index(Unique = true)] // Creates Unique Index
    public string Email { get; set; }
    
    public Dictionary PhoneNumbers { get; set; }  //Blobbed
    public Dictionary Addresses { get; set; }  //Blobbed
    public DateTime CreatedAt { get; set; }
}

public class Order {
    
    [AutoIncrement]
    public int Id { get; set; }
    
    [References(typeof(Customer))]      //Creates Foreign Key
    public int CustomerId { get; set; }
    
    [References(typeof(Employee))]      //Creates Foreign Key
    public int EmployeeId { get; set; }
    
    public Address ShippingAddress { get; set; } //Blobbed (no Address table)
    
    public DateTime? OrderDate { get; set; }
    public DateTime? RequiredDate { get; set; }
    public DateTime? ShippedDate { get; set; }
    public int? ShipVia { get; set; }
    public decimal Freight { get; set; }
    public decimal Total { get; set; }
}

public class OrderDetail {
    
    [AutoIncrement]
    public int Id { get; set; }
    
    [References(typeof(Order))] //Creates Foreign Key
    public int OrderId { get; set; }
    
    public int ProductId { get; set; }
    public decimal UnitPrice { get; set; }
    public short Quantity { get; set; }
    public decimal Discount { get; set; }
}

public class Employee {
    public int Id { get; set; }
    public string Name { get; set; }
}

public class Product {
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal UnitPrice { get; set; }
}

//Setup SQL Server Connection Factory
var dbFactory = new OrmLiteConnectionFactory(
	@"Data Source=.\SQLEXPRESS;AttachDbFilename=|DataDirectory|\App_Data\Database1.mdf;Integrated Security=True;User Instance=True",
	SqlServerDialect.Provider);

//Use in-memory Sqlite DB instead
//var dbFactory = new OrmLiteConnectionFactory(
//    ":memory:", false, SqliteDialect.Provider);

//Non-intrusive: All extension methods hang off System.Data.* interfaces
using (IDbConnection db = Config.OpenDbConnection())
{
  //Re-Create all table schemas:
  db.DropTable();
  db.DropTable();
  db.DropTable();
  db.DropTable();
  db.DropTable();

  db.CreateTable();
  db.CreateTable();
  db.CreateTable();
  db.CreateTable();
  db.CreateTable();

  db.Insert(new Employee { Id = 1, Name = "Employee 1" });
  db.Insert(new Employee { Id = 2, Name = "Employee 2" });
  var product1 = new Product { Id = 1, Name = "Product 1", UnitPrice = 10 };
  var product2 = new Product { Id = 2, Name = "Product 2", UnitPrice = 20 };
  db.Save(product1, product2);

  var customer = new Customer {
      FirstName = "Orm",
      LastName = "Lite",
      Email = "[email protected]",
      PhoneNumbers =
      {
          { PhoneType.Home, "555-1234" },
          { PhoneType.Work, "1-800-1234" },
          { PhoneType.Mobile, "818-123-4567" },
      },
      Addresses =
      {
          { AddressType.Work, new Address { 
            Line1 = "1 Street", Country = "US", State = "NY", City = "New York", ZipCode = "10101" } 
          },
      },
      CreatedAt = DateTime.UtcNow,
  };

  var customerId = db.Insert(customer, selectIdentity: true); //Get Auto Inserted Id
  customer = db.Single(new { customer.Email }); //Query
  Assert.That(customer.Id, Is.EqualTo(customerId));

  //Direct access to System.Data.Transactions:
  using (IDbTransaction trans = db.OpenTransaction(IsolationLevel.ReadCommitted))
  {
      var order = new Order {
          CustomerId = customer.Id,
          EmployeeId = 1,
          OrderDate = DateTime.UtcNow,
          Freight = 10.50m,
          ShippingAddress = new Address { 
            Line1 = "3 Street", Country = "US", State = "NY", City = "New York", ZipCode = "12121" },
      };
      db.Save(order); //Inserts 1st time

      //order.Id populated on Save().

      var orderDetails = new[] {
          new OrderDetail {
              OrderId = order.Id,
              ProductId = product1.Id,
              Quantity = 2,
              UnitPrice = product1.UnitPrice,
          },
          new OrderDetail {
              OrderId = order.Id,
              ProductId = product2.Id,
              Quantity = 2,
              UnitPrice = product2.UnitPrice,
              Discount = .15m,
          }
      };

      db.Save(orderDetails);

      order.Total = orderDetails.Sum(x => x.UnitPrice * x.Quantity * x.Discount) + order.Freight;

      db.Save(order); //Updates 2nd Time

      trans.Commit();
  }
}
 
  
Running this against a SQL Server database will yield the results below:
 
  
 
  
Notice the POCO types are stored in the very fast and Versatile JSV Format which although hard to do - is actually more compact, human and parser-friendly than JSON :)
 
  
Ignoring DTO Properties
 
  
You may use the [Ignore] attribute to denote DTO properties that are not fields in the table. This will force the SQL generation to ignore that property.
 
  
More Examples
 
  
In its simplest useage, OrmLite can persist any POCO type without any attributes required:
 
  
public class SimpleExample
{
	public int Id { get; set; }
	public string Name { get; set; }
}

//Set once before use (i.e. in a static constructor).
OrmLiteConfig.DialectProvider = SqliteDialect.Provider;

using (IDbConnection db = "/path/to/db.sqlite".OpenDbConnection())
{
	db.CreateTable(true);
	db.Insert(new SimpleExample { Id=1, Name="Hello, World!"});
	var rows = db.Select();

	Assert.That(rows, Has.Count(1));
	Assert.That(rows[0].Id, Is.EqualTo(1));
}
 
  
To get a better idea of the features of OrmLite lets walk through a complete example using sample tables from the Northwind database. _ (Full source code for this example is available here.) _
 
  
So with no other configuration using only the classes below:
 
  
[Alias("Shippers")]
public class Shipper
	: IHasId
{
	[AutoIncrement]
	[Alias("ShipperID")]
	public int Id { get; set; }

	[Required]
	[Index(Unique = true)]
	[StringLength(40)]
	public string CompanyName { get; set; }

	[StringLength(24)]
	public string Phone { get; set; }

	[References(typeof(ShipperType))]
	public int ShipperTypeId { get; set; }
}

[Alias("ShipperTypes")]
public class ShipperType
	: IHasId
{
	[AutoIncrement]
	[Alias("ShipperTypeID")]
	public int Id { get; set; }

	[Required]
	[Index(Unique = true)]
	[StringLength(40)]
	public string Name { get; set; }
}

public class SubsetOfShipper
{
	public int ShipperId { get; set; }
	public string CompanyName { get; set; }
}

public class ShipperTypeCount
{
	public int ShipperTypeId { get; set; }
	public int Total { get; set; }
}
 
  
Creating tables
 
  
Creating tables is a simple 1-liner:
 
  
using (IDbConnection db = ":memory:".OpenDbConnection())
{
    db.CreateTable();
    db.CreateTable();
}

/* In debug mode the line above prints:
DEBUG: CREATE TABLE "ShipperTypes" 
(
  "ShipperTypeID" INTEGER PRIMARY KEY AUTOINCREMENT, 
  "Name" VARCHAR(40) NOT NULL 
);
DEBUG: CREATE UNIQUE INDEX uidx_shippertypes_name ON "ShipperTypes" ("Name" ASC);
DEBUG: CREATE TABLE "Shippers" 
(
  "ShipperID" INTEGER PRIMARY KEY AUTOINCREMENT, 
  "CompanyName" VARCHAR(40) NOT NULL, 
  "Phone" VARCHAR(24) NULL, 
  "ShipperTypeId" INTEGER NOT NULL, 

  CONSTRAINT "FK_Shippers_ShipperTypes" FOREIGN KEY ("ShipperTypeId") REFERENCES "ShipperTypes" ("ShipperID") 
);
DEBUG: CREATE UNIQUE INDEX uidx_shippers_companyname ON "Shippers" ("CompanyName" ASC);
*/
 
  
Transaction Support
 
  
As we have direct access to IDbCommand and friends - playing with transactions is easy:
 
  
var trainsType = new ShipperType { Name = "Trains" };
var planesType = new ShipperType { Name = "Planes" };

//Playing with transactions
using (IDbTransaction dbTrans = db.OpenTransaction())
{
    db.Save(trainsType);
    db.Save(planesType);

    dbTrans.Commit();
}

using (IDbTransaction dbTrans = db.OpenTransaction(IsolationLevel.ReadCommitted))
{
    db.Insert(new ShipperType { Name = "Automobiles" });
    Assert.That(db.Select(), Has.Count.EqualTo(3));
}
Assert.That(db.Select(), Has.Count(2));
 
  
CRUD Operations
 
  
No ORM is complete without the standard crud operations:
 
  
	//Performing standard Insert's and Selects
  db.Insert(new Shipper { CompanyName = "Trains R Us", Phone = "555-TRAINS", ShipperTypeId = trainsType.Id });
  db.Insert(new Shipper { CompanyName = "Planes R Us", Phone = "555-PLANES", ShipperTypeId = planesType.Id });
  db.Insert(new Shipper { CompanyName = "We do everything!", Phone = "555-UNICORNS", ShipperTypeId = planesType.Id });

  var trainsAreUs = db.Single("ShipperTypeId = @Id", new { trainsType.Id });
  Assert.That(trainsAreUs.CompanyName, Is.EqualTo("Trains R Us"));
  Assert.That(db.Select("CompanyName = @company OR Phone = @phone", 
        new { company = "Trains R Us", phone = "555-UNICORNS" }), Has.Count.EqualTo(2));
  Assert.That(db.Select("ShipperTypeId = @Id", new { planesType.Id }), Has.Count.EqualTo(2));

  //Lets update a record
  trainsAreUs.Phone = "666-TRAINS";
  db.Update(trainsAreUs);
          Assert.That(db.SingleById(trainsAreUs.Id).Phone, Is.EqualTo("666-TRAINS"));
  
  //Then make it dissappear
  db.Delete(trainsAreUs);
          Assert.That(db.SingleById(trainsAreUs.Id), Is.Null);

  //And bring it back again
  db.Insert(trainsAreUs);
 
  
Performing custom queries
 
  
And with access to raw sql when you need it - the database is your oyster :)
 
  
var partialColumns = db.Select(typeof(Shipper), 
    "ShipperTypeId = @Id", new { planesType.Id });
Assert.That(partialColumns, Has.Count.EqualTo(2));

//Select into another POCO class that matches sql
var rows = db.Select(
    "SELECT ShipperTypeId, COUNT(*) AS Total FROM Shippers GROUP BY ShipperTypeId ORDER BY COUNT(*)");

Assert.That(rows, Has.Count.EqualTo(2));
Assert.That(rows[0].ShipperTypeId, Is.EqualTo(trainsType.Id));
Assert.That(rows[0].Total, Is.EqualTo(1));
Assert.That(rows[1].ShipperTypeId, Is.EqualTo(planesType.Id));
Assert.That(rows[1].Total, Is.EqualTo(2));


//And finally lets quickly clean up the mess we've made:
db.DeleteAll();
db.DeleteAll();

Assert.That(db.Select(), Has.Count.EqualTo(0));
Assert.That(db.Select(), Has.Count.EqualTo(0));
 
  
Soft Deletes
 
  
Select Filters let you specify a custom SelectFilter that lets you modify queries that use SqlExpression before they're executed. This could be used to make working with "Soft Deletes" Tables easier where it can be made to apply a custom x.IsDeleted != true condition on every SqlExpression.
 
  
By either using a SelectFilter on concrete POCO Table Types, e.g:
 
  
SqlExpression.SelectFilter = q => q.Where(x => x.IsDeleted != true);
SqlExpression.SelectFilter = q => q.Where(x => x.IsDeleted != true);
 
  
Or alternatively using generic delegate that applies to all SqlExpressions, but you'll only have access to aIUntypedSqlExpression which offers a limited API surface area but will still let you execute a custom filter for all SqlExpression that could be used to add a condition for all tables implementing a custom ISoftDelete interface with:
 
  
OrmLiteConfig.SqlExpressionSelectFilter = q =>
{
    if (q.ModelDef.ModelType.HasInterface(typeof(ISoftDelete)))
    {
        q.Where(x => x.IsDeleted != true);
    }
};
 
  
Both solutions above will transparently add the x.IsDeleted != true to all SqlExpression based queries so it only returns results which aren't IsDeleted from any of queries below:
 
  
var results = db.Select(db.From());
var result = db.Single(db.From().Where(x => x.Name == "foo"));
var result = db.Single(x => x.Name == "foo"); 
  
Check Constraints
 
  
OrmLite includes support for SQL Check Constraints which will create your Table schema with the [CheckConstraint]specified, e.g:
 
  
public class Table
{
    [AutoIncrement]
    public int Id { get; set; }

    [Required]
    [CheckConstraint("Age > 1")]
    public int Age { get; set; }

    [CheckConstraint("Name IS NOT NULL")]
    public string Name { get; set; }
}
 
  
Bitwise operators
 
  
The Typed SqlExpression bitwise operations support depends on the RDBMS used.
 
  
E.g. all RDBMS's support Bitwise And and Or operators:
 
  
db.Select(x => (x.Id | 2) == 3);
db.Select(x => (x.Id & 2) == 2); 
  
All RDBMS Except for SQL Server support bit shift operators:
 
  
db.Select(x => (x.Id << 1) == 4);
db.Select(x => (x.Id >> 1) == 1); 
  
Whilst only SQL Server and MySQL Support Exclusive Or:
 
  
db.Select(x => (x.Id ^ 2) == 3); 
  
SQL Server Features
 
  
Memory Optimized Tables
 
  
OrmLite allows access to many advanced SQL Server features including Memory-Optimized Tables where you can tell SQL Server to maintain specific tables in Memory using the [SqlServerMemoryOptimized] attribute, e.g:
 
  
[SqlServerMemoryOptimized(SqlServerDurability.SchemaOnly)]
public class SqlServerMemoryOptimizedCacheEntry : ICacheEntry
{
    [PrimaryKey]
    [StringLength(StringLengthAttribute.MaxText)]
    [SqlServerBucketCount(10000000)]
    public string Id { get; set; }
    [StringLength(StringLengthAttribute.MaxText)]
    public string Data { get; set; }
    public DateTime CreatedDate { get; set; }
    public DateTime? ExpiryDate { get; set; }
    public DateTime ModifiedDate { get; set; }
}
 
  
The [SqlServerBucketCount] attribute can be used to configure the bucket count for a hash index whilst the new [SqlServerCollate] attribute can be used to specify an SQL Server collation.
 
  
PostgreSQL Features
 
  
PostgreSQL Data Types
 
  
The [PgSql*] specific attributes lets you use attributes to define PostgreSQL rich data types, e.g:
 
  
public class MyPostgreSqlTable
{
    [PgSqlJson]
    public List AsJson { get; set; }

    [PgSqlJsonB]
    public List AsJsonB { get; set; }

    [PgSqlTextArray]
    public string[] AsTextArray { get; set; }

    [PgSqlIntArray]
    public int[] AsIntArray { get; set; }

    [PgSqlBigIntArray]
    public long[] AsLongArray { get; set; }
}
 
  
Limitations
 
  
Single Primary Key
 
  
For simplicity, and to be able to have the same POCO class persisted in db4o, memcached, redis or on the filesystem (i.e. providers included in ServiceStack), each model must have a single primary key, by convention OrmLite expects it to be Idalthough you use [Alias("DbFieldName")] attribute it map it to a column with a different name or use the [PrimaryKey]attribute to tell OrmLite to use a different property for the primary key.
 
  
You can still SELECT from these tables, you will just be unable to make use of APIs that rely on it, e.g. Update or Deletewhere the filter is implied (i.e. not specified), all the APIs that end with ById, etc.
 
  
Optimize LIKE Searches
 
  
One of the primary goals of OrmLite is to expose and RDBMS agnostic Typed API Surface which will allow you to easily switch databases, or access multiple databases at the same time with the same behavior.
 
  
One instance where this can have an impact is needing to use UPPER() in LIKE searches to enable case-insensitive LIKEqueries across all RDBMS. The drawback of this is that LIKE Queries are not able to use any existing RDBMS indexes. We can disable this feature and return to the default RDBMS behavior with:
 
  
OrmLiteConfig.StripUpperInLike = true;
 
  
Allowing all LIKE Searches in OrmLite or AutoQuery to use any available RDBMS Index.
 
  
Oracle Provider Notes
 
  
The Oracle provider requires an installation of Oracle's ODP.NET. It has been tested with Oracle 11g but should work with 10g and perhaps even older versions. It has not been tested with Oracle 12c and does not support any new 12c features such as AutoIncrement keys. It also does not support the new Oracle fully-managed client.
 
  
By default the Oracle provider stores Guids in the database as character strings and when generating SQL it quotes only table and column names that are reserved words in Oracle. That requires that you use the same quoting if you code your own SQL. Both of these options can be overridden, but overriding them will cause problems: the provider can store Guids as raw(16) but it cannot read them.
 
  
The Oracle provider uses Oracle sequences to implement AutoIncrement columns and it queries the sequence to get a new value in a separate database call. You can override the automatically generated sequence name with a
 
  
[Sequence("name")]
 
  
attribute on a field. The Sequence attribute implies [AutoIncrement], but you can use both on the same field.
 
  
Since Oracle has a very restrictive 30 character limit on names, it is strongly suggested that you use short entity class and field names or aliases, remembering that indexes and foreign keys get compound names. If you use long names, the provider will squash them to make them compliant with the restriction. The algorithm used is to remove all vowels ("aeiouy") and if still too long then every fourth letter starting with the third one and finally if still too long to truncate the name. You must apply the same squashing algorithm if you are coding your own SQL.
 
  
The previous version of ServiceStack.OrmLite.Oracle used System.Data.OracleClient to talk to the database. Microsoft has deprecated that client, but it does still mostly work if you construct the Oracle provider like this:
 
  
OracleOrmLiteDialectProvider.Instance = new OracleOrmLiteDialectProvider(
compactGuid: false,
quoteNames: false,
clientProvider: OracleOrmLiteDialectProvider.MicrosoftProvider); 
 
  
DateTimeOffset fields and, in locales that use a comma to separate the fractional part of a floating point number, some aspects of using floating point numbers, do not work with System.Data.OracleClient.
 
  
Community Resources
 
  
 
   
OrmLite and Redis: New alternatives for handling db communication by @abtosoftware
 
   
Object Serialization as Step Towards Normalization by @ 82unpluggd
 
   
Creating a Data Access Layer using OrmLite by Lydon Bergin
 
   
Code Generation using ServiceStack.OrmLite and T4 Text templates by @jokecamp
 
   
Simple ServiceStack OrmLite Example by @robrtc
 
   
OrmLite Blobbing done with NHibernate and Serialized JSON by @philliphaydon
 
   
Creating An ASP.NET MVC Blog With ServiceStack.OrmLite by @peterbromberg
 
  
 
  
Other notable Micro ORMs for .NET
 
  
Many performance problems can be mitigated and a lot of use-cases can be simplified without the use of a heavyweight ORM, and their config, mappings and infrastructure. As performance is the most important feature we can recommend the following list, each with their own unique special blend of features.
 
  
 
   
Dapper - by @samsaffron and @marcgravell 
    
 
     
The current performance king, supports both POCO and dynamic access, fits in a single class. Put in production to solve StackOverflow's DB Perf issues. Requires .NET 4.
 
    
 
   
PetaPoco - by @toptensoftware 
    
 
     
Fast, supports dynamics, expandos and typed POCOs, fits in a single class, runs on .NET 3.5 and Mono. Includes optional T4 templates for POCO table generation.
 
    
 
   
Massive - by @robconery 
    
 
     
Fast, supports dynamics and expandos, smart use of optional params to provide a wrist-friendly api, fits in a single class. Multiple RDBMS support. Requires .NET 4.
 
    
 
   
Simple.Data - by @markrendle 
    
 
     
A little slower than above ORMS, most wrist-friendly courtesy of a dynamic API, multiple RDBMS support inc. Mongo DB. Requires .NET 4.
 
    
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    

                        
                        

                            
 
                        
                        
                        

                            

                        
                        
                        

                            

                        
                    
                
            
        
    
    

        
你可能感兴趣的:(ServiceStack.OrmLite)
        

            

                

                    
.NET(C#)有哪些主流的ORM框架，FreeSql，SqlSugar，Dapper，EF还是...
                        2881099
.netcore.netorm
                        
前言在以前的一篇文章中，为大家分享了《什么是ORM？为什么用ORM？浅析ORM的使用及利弊》。那么，在目前的.NET(C#)的世界里，有哪些主流的ORM，FreeSql，SqlSugar，Dapper，EntityFramework(EF)还是ServiceStack.OrmLite？或者是你还有更好的ORM推荐呢？如果有的话，不防也一起分享给大家。.NET(C#)主流ORM总揽今天这篇文章分享几
                    
                    
.NET(C#)有哪些主流的ORM框架，FreeSql，SqlSugar，Dapper，EF还是...
                        2881099
.netcore.netorm
                        
前言在以前的一篇文章中，为大家分享了《什么是ORM？为什么用ORM？浅析ORM的使用及利弊》。那么，在目前的.NET(C#)的世界里，有哪些主流的ORM，FreeSql，SqlSugar，Dapper，EntityFramework(EF)还是ServiceStack.OrmLite？或者是你还有更好的ORM推荐呢？如果有的话，不防也一起分享给大家。.NET(C#)主流ORM总揽今天这篇文章分享几
                    
                    
ServiceStack
                        人如飘絮花亦伤
C#学习笔记ServerStack
                        
ServiceStack.OrmLite是一个开源的无配置的轻量级.NET和Mono的ORM框架。我的毕设就是用它搭建起来的，用起来挺好用的，下面我把我毕设的搭建步骤写下来。首先是NuGet包的下载（因为我数据库用的是mysql，ormlite有8个版本的还有sqlserver，Oracle，sqlite等）Install-PackageServiceStack.OrmLite.MySql加载出来
                    
                    
目前的.NET(C#)世界里，有哪些主流的ORM--SqlSugar，Dapper，Entity Framework(EF)还是...
                        WEST911
c#
                        
在以前的一篇文章中，为大家分享了《什么是ORM？为什么用ORM？浅析ORM的使用及利弊》。那么，在目前的.NET(C#)的世界里，有哪些主流的ORM，SqlSugar，Dapper，EntityFramework(EF)还是ServiceStack.OrmLite？或者是你还有更好的ORM推荐呢？如果有的话，不防也一起分享给大家。.NET(C#)主流ORM总揽今天这篇文章分享几款收集的目前.NET
                    
                    
.NET(C#)有哪些主流的ORM框架，SqlSugar，Dapper，EF还是...
                        weixin_34362875

                        
前言在以前的一篇文章中，为大家分享了《什么是ORM？为什么用ORM？浅析ORM的使用及利弊》。那么，在目前的.NET(C#)的世界里，有哪些主流的ORM，SqlSugar，Dapper，EntityFramework(EF)还是ServiceStack.OrmLite？或者是你还有更好的ORM推荐呢？如果有的话，不防也一起分享给大家。.NET(C#)主流ORM总揽今天这篇文章分享几款收集的目前.N
                    
                    
浅谈c#垃圾回收机制（GC）
                        weixin_30399155

                        
写了一个window服务，循环更新sqlite记录，内存一点点稳步增长。三天后，内存溢出。于是，我从自己的代码入手，查找到底哪儿占用内存释放不掉，最终明确是调用servicestack.ormlite更新sqlite数据库造成的。至于是不是框架问题，可能性不大，因为本地模拟执行的代码没有任何问题。我觉得应该是orm在执行数据库更新后，对象还在被引用造成的。这里，我贴出一个伪代码：//存放对象的一个
                    
                    
.NET(C#)主流的ORM框架
                        lnc2003
C#
                        
.NET(C#)主流ORM总揽SqlSugar(国内)Dos.ORM(国内)Chloe(国内)StackExchange/Dapper(国外)EntityFramework(EF)(国外)NHibernate(国外)ServiceStack/ServiceStack.OrmLite(国外)linq2db(国外)Massive(国外)PetaPoco(国外)SqlSugarSqlSugar是国人开发
                    
                    
.NET主流的ORM框架
                        星Ge随笔
ORM
                        
C#.NET主流ORM框架举例：1.FreeSql(国内)2.SqlSugar(国内)3.Dos.ORM(国内)4.Chloe(国内)5.StackExchange/Dapper(国外)6.EntityFramework(EF)(国外)7.NHibernate(国外)8.ServiceStack/ServiceStack.OrmLite(国外)9.linq2db(国外)10.Massive(国外)
                    
                    
目前的.NET(C#)世界里，有哪些主流的ORM--SqlSugar，Dapper，Entity Framework(EF)还是...
                        Rector

                        
目前的.NET(C#)世界里，有哪些主流的ORM--SqlSugar，Dapper，EntityFramework(EF)还是...在以前的一篇文章中，为大家分享了《什么是ORM？为什么用ORM？浅析ORM的使用及利弊》。那么，在目前的.NET(C#)的世界里，有哪些主流的ORM，SqlSugar，Dapper，EntityFramework(EF)还是ServiceStack.OrmLite？或
                    
                    
.NET(C#)有哪些主流的ORM框架
                        古萧龙城好青年

                        
前言在以前的一篇文章中，为大家分享了《什么是ORM？为什么用ORM？浅析ORM的使用及利弊》。那么，在目前的.NET(C#)的世界里，有哪些主流的ORM，SqlSugar，Dapper，EntityFramework(EF)还是ServiceStack.OrmLite？或者是你还有更好的ORM推荐呢？如果有的话，不防也一起分享给大家。.NET(C#)主流ORM总揽今天这篇文章分享几款收集的目前.N
                    
                    
.NET(C#)有哪些主流的ORM框架
                        sinolover
#abp#net框架
                        
前言在以前的一篇文章中，为大家分享了《什么是ORM？为什么用ORM？浅析ORM的使用及利弊》。那么，在目前的.NET(C#)的世界里，有哪些主流的ORM，SqlSugar，Dapper，EntityFramework(EF)还是ServiceStack.OrmLite？或者是你还有更好的ORM推荐呢？如果有的话，不防也一起分享给大家。.NET(C#)主流ORM总揽今天这篇文章分享几款收集的目前.N
                    
                    
ServiceStack.OrmLite
                        Duan_Super

                        
Follow@ServiceStackorjointheGoogle+Communityforupdates,orStackOverflowortheCustomerForumsforsupport.Fast,Simple,TypedORMfor.NETOrmLite'sgoalistoprovideaconvenient,DRY,config-free,RDBMS-agnostictypedwr
                    
                    
ServiceStack.OrmLite
                        Duan_Super

                        
Follow@ServiceStackorjointheGoogle+Communityforupdates,orStackOverflowortheCustomerForumsforsupport.Fast,Simple,TypedORMfor.NETOrmLite'sgoalistoprovideaconvenient,DRY,config-free,RDBMS-agnostictypedwr
                    
                    
.NET(C#)有哪些主流的ORM框架，FreeSql，SqlSugar，Dapper，EF还是...
                        2881099
orm.net.netcore
                        
前言在以前的一篇文章中，为大家分享了《什么是ORM？为什么用ORM？浅析ORM的使用及利弊》。那么，在目前的.NET(C#)的世界里，有哪些主流的ORM，FreeSql，SqlSugar，Dapper，EntityFramework(EF)还是ServiceStack.OrmLite？或者是你还有更好的ORM推荐呢？如果有的话，不防也一起分享给大家。.NET(C#)主流ORM总揽今天这篇文章分享几
                    
                    
C#中流行的ORM框架
                        num197
C#
                        
前言在目前的.NET(C#)的世界里，有哪些主流的ORM，SqlSugar，Dapper，EntityFramework(EF)还是ServiceStack.OrmLite？或者是你还有更好的ORM推荐呢？如果有的话，不防也一起分享给大家。.NET(C#)主流ORM总揽今天这篇文章分享几款收集的目前.NET(C#)中比较流行的ORM框架，比如(以下框架均为开源框架，托管于github上)：SqlS
                    
                    
.NET(C#)有哪些主流的ORM框架，SqlSugar，Dapper，EF还是...
                        RECTOR
orm.netc#asp.netasp.net-mvc
                        
前言在以前的一篇文章中，为大家分享了《什么是ORM？为什么用ORM？浅析ORM的使用及利弊》。那么，在目前的.NET(C#)的世界里，有哪些主流的ORM，SqlSugar，Dapper，EntityFramework(EF)还是ServiceStack.OrmLite？或者是你还有更好的ORM推荐呢？如果有的话，不防也一起分享给大家。.NET(C#)主流ORM总揽今天这篇文章分享几款收集的目前.N
                    
                    
EF通用数据层封装类（支持读写分离，一主多从）
                        slowlifes
EntityFrameworkC#
                        
阅读目录浅谈orm浅谈EntityFrameworkEntityFramework通用数据层类扩展类，实现读写分离进一步改造，实现多从库读取参考文章源码分享回到顶部浅谈orm记得四年前在学校第一次接触到LingtoSql，那时候瞬间发现不用手写sql语句是多么的方便，后面慢慢的接触了许多orm框架，像EF，Dapper,Hibernate,ServiceStack.OrmLite等。当然每种orm
                    
                    
ServiceStack.OrmLite 笔记10-group having 分页orderby等
                        过错

                        
grouphaving分页等varev=OrmLiteConfig.DialectProvider.SqlExpression();group的使用同sql一样，注意group分组的字段要在select里ev.Select(c=>new{c.Birthday,c.Active}).Where(rn=>rn.Birthday>=newDateTime(year,1,1)&&rn.Birthdayne
                    
                    
ServiceStack.OrmLite 笔记9 -code first 必须的代码优先
                        过错

                        
复杂点的使用3codefirst的使用，支持复杂类型publicenumPhoneType{Home,Work,Mobile,}publicenumAddressType{Home,Work,Other,}publicclassAddress{publicstringLine1{get;set;}publicstringLine2{get;set;}publicstringZipCode{get;
                    
                    
ServiceStack.OrmLite 笔记8 -还是有用的姿势
                        过错

                        
复杂点的使用2InsertAll,UpdateAllandDeleteAll的参数要是IEnumerablesEach关键字返回IEnumerable并且是延迟加载的全局设置当字符串为null时候，设置一个默认值OrmLiteConfig.OnDbNullFilter=fieldDef=>fieldDef.FieldType==typeof(string)?"NULL":null;---执行sql
                    
                    
ServiceStack.OrmLite 学习笔记7-复杂点的使用1
                        过错

                        
复杂点的使用1先看看这2个类classCustomer{publicintId{get;set;}...}classCustomerAddress{publicintId{get;set;}publicintCustomerId{get;set;}//ReferencebasedonPropertynameconvention}---也支持别名[Alias("LegacyCustomer")]cl
                    
                    
ServiceStack.OrmLite 6 学习笔记 查
                        过错

                        
查根据id
varresult=db.SingleById(1);根据字段
varcustomer=db.Single(new{customer.Email});动态结果
db.Select>(db.From().Select("COUNT(*),MIN(Id),MAX(Id)"))[0];
//List:[10,1,10]

同上
db.Select>(db.From().Select("COU
                    
                    
ServiceStack.OrmLite 笔记5 改
                        过错

                        
修改db.Update(newPerson{Id=1,FirstName="Jimi",LastName="Hendrix",Age=27});//sql:UPDATE"Person"SET"FirstName"='Jimi',"LastName"='Hendrix',"Age"=27WHERE"Id"=1db.Update(newPerson{Id=1,FirstName="JJ"},p=>p.
                    
                    
ServiceStack.OrmLite 笔记4 删
                        过错

                        
删除db.DeleteAll();//各种姿势db.Delete(p=>p.Age==27);//db.Delete(q=>q.Where(p=>p.Age==27));//同上db.Delete(where:"Age={0}".Params(27));db.Delete(table:"Person",where:"Age={0}".Params(27));//sql:DELETEFROM"Per
                    
                    
ServiceStack.OrmLite 学习笔记3 建表
                        过错

                        
创建表前一篇忘记写创建表了，这里补上。（其实前一篇也有那么一点）建议安装源码里的t4模板看看效果先。public的属性才有效在表被创建或者删除的时候执行sql语句[PostCreateTable("INSERTINTOTableWithSeedData(Name)VALUES('Foo');"+"INSERTINTOTableWithSeedData(Name)VALUES('Bar');")]p
                    
                    
ServiceStack.OrmLite 笔记2 -增
                        过错

                        
ServiceStack.OrmLite笔记2这篇主要介绍增加db.Insert(newEmployee{Id=1,Name="Employee1"});//默认同步awaitdb.InsertAsync(newEmployee{Id=1,Name="Employee1"});//异步其他的异步类似这里的这个示例db.InsertOnly(newPerson{FirstName="Amy"},q=
                    
                    
测试EF6.1.3和OrmLite性能
                        
orm
                        
     公司原来用nhibernate，现在考虑要不要换一种ORM，于是找来了EF和ServiceStack.OrmLite。所以就产生了测试这三个性能的要求。对比三个ORM工具的性能，主要是对比ORM配置和启动速度；建表速度；插入行速度；修改行速度以及查询速度，删除用的比较少，就不测试了，还有发现EF貌似比nhibernate稍微快一些，就只测EF和Service
                    
                    
Dapper小型ORM的使用（随便吐槽下公司）
                        
orm
                        
 　　近来公司又有新项目要做，之前做项目用过蛮多ORM，包括ef,NetTiers,ServiceStack.OrmLite等ROM，每种ORM都有一定的坑（或者说是使用者的问题吧~~）。用来用去都觉的有一定的不爽。这次打算用Dapper这个ORM来做项目看看。首先感谢http://www.cnblogs.com/wywnet/p/33422150.html这位老兄给出的文章还有demo
                    
                    
测试EF6.1.3和OrmLite性能
                        hambert

                        
公司原来用nhibernate，现在考虑要不要换一种ORM，于是找来了EF和ServiceStack.OrmLite。所以就产生了测试这三个性能的要求。对比三个ORM工具的性能，主要是对比ORM配置和启动速度；建表速度；插入行速度；修改行速度以及查询速度，删除用的比较少，就不测试了，还有发现EF貌似比nhibernate稍微快一些，就只测EF和ServiceStack.OrmLite了。测试表结构
                    
                    
ServiceStack.OrmLite的参考资料（E文）
                        九界蓝图
数据库ormormliteServiceStack
                        
OrmLite是ServiceStack内置的数据库操作支持模块，通过ORM方式可以使用多种数据库，包括对NoSQL类型的数据库的支持。AnOpenSourceMicroORMfor.NEThttps://github.com/ServiceStack/ServiceStack.OrmLite/tree/v3这个是官方的OrmLite的单页的说明文件，包含有OrmLite的介绍以及使用语法，下载和
                    
                                
Spring中@Value注解，需要注意的地方
                                    无量
springbean@Valuexml
                                    
Spring 3以后,支持@Value注解的方式获取properties文件中的配置值，简化了读取配置文件的复杂操作 
 
 
1、在applicationContext.xml文件(或引用文件中)中配置properties文件 
 
<bean id="appProperty"
    class="org.springframework.beans.fac
                                
                                
mongoDB 分片
                                    开窍的石头
mongodb
                                    
    mongoDB的分片。要mongos查询数据时候 先查询configsvr看数据在那台shard上，configsvr上边放的是metar信息，指的是那条数据在那个片上。由此可以看出mongo在做分片的时候咱们至少要有一个configsvr,和两个以上的shard（片）信息。 
    第一步启动两台以上的mongo服务 
&nb
                                
                                
OVER(PARTITION BY)函数用法
                                    0624chenhong
oracle
                                    
这篇写得很好，引自 
http://www.cnblogs.com/lanzi/archive/2010/10/26/1861338.html 
 
 
OVER(PARTITION BY)函数用法 
 
 2010年10月26日 
 
OVER(PARTITION BY)函数介绍 
 
开窗函数        &nb
                                
                                
Android开发中，ADB server didn't ACK 解决方法
                                    一炮送你回车库
Android开发
                                    
首先通知：凡是安装360、豌豆荚、腾讯管家的全部卸载，然后再尝试。 
  
一直没搞明白这个问题咋出现的，但今天看到一个方法，搞定了！原来是豌豆荚占用了 5037 端口导致。 
参见原文章：一个豌豆荚引发的血案——关于ADB server didn't ACK的问题 
简单来讲，首先将Windows任务进程中的豌豆荚干掉，如果还是不行，再继续按下列步骤排查。 
&nb
                                
                                
canvas中的像素绘制问题
                                    换个号韩国红果果
JavaScriptcanvas
                                    
pixl的绘制，1.如果绘制点正处于相邻像素交叉线，绘制x像素的线宽，则从交叉线分别向前向后绘制x/2个像素，如果x/2是整数，则刚好填满x个像素，如果是小数，则先把整数格填满，再去绘制剩下的小数部分，绘制时，是将小数部分的颜色用来除以一个像素的宽度，颜色会变淡。所以要用整数坐标来画的话（即绘制点正处于相邻像素交叉线时），线宽必须是2的整数倍。否则会出现不饱满的像素。 
2.如果绘制点为一个像素的
                                
                                
编码乱码问题
                                    灵静志远
javajvmjsp编码
                                    
1、JVM中单个字符占用的字节长度跟编码方式有关，而默认编码方式又跟平台是一一对应的或说平台决定了默认字符编码方式；2、对于单个字符：ISO-8859-1单字节编码，GBK双字节编码，UTF-8三字节编码；因此中文平台(中文平台默认字符集编码GBK)下一个中文字符占2个字节，而英文平台(英文平台默认字符集编码Cp1252(类似于ISO-8859-1))。 
3、getBytes()、getByte
                                
                                
java 求几个月后的日期
                                    darkranger
calendargetinstance
                                    
Date plandate = planDate.toDate();
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Calendar cal = Calendar.getInstance();
cal.setTime(plandate);
// 取得三个月后时间
cal.add(Calendar.M
                                
                                
数据库设计的三大范式（通俗易懂）
                                    aijuans
数据库复习
                                    
关系数据库中的关系必须满足一定的要求。满足不同程度要求的为不同范式。数据库的设计范式是数据库设计所需要满足的规范。只有理解数据库的设计范式，才能设计出高效率、优雅的数据库，否则可能会设计出错误的数据库. 
目前，主要有六种范式：第一范式、第二范式、第三范式、BC范式、第四范式和第五范式。满足最低要求的叫第一范式，简称1NF。在第一范式基础上进一步满足一些要求的为第二范式，简称2NF。其余依此类推。
                                
                                
想学工作流怎么入手
                                    atongyeye
jbpm
                                    
工作流在工作中变得越来越重要，很多朋友想学工作流却不知如何入手。 很多朋友习惯性的这看一点，那了解一点，既不系统，也容易半途而废。好比学武功，最好的办法是有一本武功秘籍。研究明白，则犹如打通任督二脉。 
 
 
系统学习工作流，很重要的一本书《JBPM工作流开发指南》。 
 
本人苦苦学习两个月，基本上可以解决大部分流程问题。整理一下学习思路，有兴趣的朋友可以参考下。 
 
1  首先要
                                
                                
Context和SQLiteOpenHelper创建数据库
                                    百合不是茶
androidContext创建数据库
                                    
       一直以为安卓数据库的创建就是使用SQLiteOpenHelper创建,但是最近在android的一本书上看到了Context也可以创建数据库,下面我们一起分析这两种方式创建数据库的方式和区别,重点在SQLiteOpenHelper 
  
  
一:SQLiteOpenHelper创建数据库: 
  
1,SQLi
                                
                                
浅谈group by和distinct
                                    bijian1013
oracle数据库group bydistinct
                                    
        group by和distinct只了去重意义一样，但是group by应用范围更广泛些，如分组汇总或者从聚合函数里筛选数据等。 
        譬如：统计每id数并且只显示数大于3 
select id ,count(id) from ta
                                
                                
vi opertion
                                    征客丶
macoprationvi
                                    
进入 command mode （命令行模式） 
按 esc 键 
再按 shift + 冒号 
 
注：以下命令中 带 $ 【在命令行模式下进行】，不带 $ 【在非命令行模式下进行】 
 
一、文件操作 
1.1、强制退出不保存 
$ q! 
1.2、保存 
$ w 
1.3、保存并退出 
$ wq 
1.4、刷新或重新加载已打开的文件 
$ e 
 
二、光标移动 
2.1、跳到指定行 
数字
                                
                                
【Spark十四】深入Spark RDD第三部分RDD基本API
                                    bit1129
spark
                                    
  
对于K/V类型的RDD,如下操作是什么含义？ 
  
val rdd = sc.parallelize(List(("A",3),("C",6),("A",1),("B",5))
rdd.reduceByKey(_+_).collect 
 reduceByKey在这里的操作，是把
                                
                                
java类加载机制
                                    BlueSkator
java虚拟机
                                    
java类加载机制 
1.java类加载器的树状结构 
引导类加载器 
^ 
| 
扩展类加载器 
^ 
| 
系统类加载器 
java使用代理模式来完成类加载，java的类加载器也有类似于继承的关系，引导类是最顶层的加载器，它是所有类的根加载器，它负责加载java核心库。当一个类加载器接到装载类到虚拟机的请求时，通常会代理给父类加载器，若已经是根加载器了，就自己完成加载。 
虚拟机区分一个Cla
                                
                                
动态添加文本框
                                    BreakingBad
文本框
                                    
  <script>     var num=1; function AddInput() {      var str="";     str+="<input 
                                
                                
读《研磨设计模式》-代码笔记-单例模式
                                    bylijinnan
java设计模式
                                    
声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



public class Singleton {
}

/*
 * 懒汉模式。注意，getInstance如果在多线程环境中调用，需要加上synchronized，否则存在线程不安全问题
 */
class LazySingleton
                                
                                
iOS应用打包发布常见问题
                                    chenhbc
iosiOS发布iOS上传iOS打包
                                    
这个月公司安排我一个人做iOS客户端开发，由于急着用，我先发布一个版本，由于第一次发布iOS应用，期间出了不少问题，记录于此。 
  
1、使用Application Loader 发布时报错：Communication error.please use diagnostic mode to check connectivity.you need to have outbound acc
                                
                                
工作流复杂拓扑结构处理新思路
                                    comsci
设计模式工作算法企业应用OO
                                    
 我们走的设计路线和国外的产品不太一样，不一样在哪里呢？  国外的流程的设计思路是通过事先定义一整套规则(类似XPDL)来约束和控制流程图的复杂度(我对国外的产品了解不够多，仅仅是在有限的了解程度上面提出这样的看法)，从而避免在流程引擎中处理这些复杂的图的问题，而我们却没有通过事先定义这样的复杂的规则来约束和降低用户自定义流程图的灵活性，这样一来，在引擎和流程流转控制这一个层面就会遇到很
                                
                                
oracle 11g新特性Flashback data archive
                                    daizj
oracle
                                    
1. 什么是flashback data archive 
 
Flashback data archive是oracle 11g中引入的一个新特性。Flashback archive是一个新的数据库对象，用于存储一个或多表的历史数据。Flashback archive是一个逻辑对象，概念上类似于表空间。实际上flashback archive可以看作是存储一个或多个表的所有事务变化的逻辑空间。 
                                
                                
多叉树:2-3-4树
                                    dieslrae
树
                                    
    平衡树多叉树,每个节点最多有4个子节点和3个数据项,2,3,4的含义是指一个节点可能含有的子节点的个数,效率比红黑树稍差.一般不允许出现重复关键字值.2-3-4树有以下特征: 
    1、有一个数据项的节点总是有2个子节点(称为2-节点) 
    2、有两个数据项的节点总是有3个子节点(称为3-节
                                
                                
C语言学习七动态分配 malloc的使用
                                    dcj3sjt126com
clanguagemalloc
                                    
/*
	2013年3月15日15:16:24
	malloc 就memory(内存) allocate(分配)的缩写
	本程序没有实际含义，只是理解使用	
 */
# include <stdio.h>
# include <malloc.h>

int main(void)
{
	int i = 5;	//分配了4个字节 静态分配
	int * p 
                                
                                
Objective-C编码规范[译]
                                    dcj3sjt126com
代码规范
                                    
     
 
  
  原文链接 : The official raywenderlich.com Objective-C style guide  
  原文作者 : raywenderlich.com Team  
  译文出自 : raywenderlich.com Objective-C编码规范  
  译者 : Sam Lau  
  
                                
                                
0.性能优化-目录
                                    frank1234
性能优化
                                    
从今天开始笔者陆续发表一些性能测试相关的文章，主要是对自己前段时间学习的总结，由于水平有限，性能测试领域很深，本人理解的也比较浅，欢迎各位大咖批评指正。 
主要内容包括： 
一、性能测试指标 
吞吐量、TPS、响应时间、负载、可扩展性、PV、思考时间 
http://frank1234.iteye.com/blog/2180305 
 
二、性能测试策略 
生产环境相同 基准测试 预热等 
htt
                                
                                
Java父类取得子类传递的泛型参数Class类型
                                    happyqing
java泛型父类子类Class
                                    
  
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import org.junit.Test;

abstract class BaseDao<T> {
	public void getType() {
		//Class<E> clazz =
                                
                                
跟我学SpringMVC目录汇总贴、PDF下载、源码下载
                                    jinnianshilongnian
springMVC
                                    
  
----广告-------------------------------------------------------------- 
网站核心商详页开发 
掌握Java技术，掌握并发/异步工具使用，熟悉spring、ibatis框架； 
掌握数据库技术，表设计和索引优化，分库分表/读写分离； 
了解缓存技术，熟练使用如Redis/Memcached等主流技术； 
了解Ngin
                                
                                
the HTTP rewrite module requires the PCRE library
                                    流浪鱼
rewrite
                                    
./configure: error: the HTTP rewrite module requires the PCRE library. 
模块依赖性Nginx需要依赖下面3个包 
1. gzip 模块需要 zlib 库 ( 下载: http://www.zlib.net/ ) 
2. rewrite 模块需要 pcre 库 ( 下载: http://www.pcre.org/ ) 
3. s
                                
                                
第12章 Ajax（中）
                                    onestopweb
Ajax
                                    
index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
                                
                                
Optimize query with Query Stripping in Web Intelligence
                                    blueoxygen
BO
                                    
http://wiki.sdn.sap.com/wiki/display/BOBJ/Optimize+query+with+Query+Stripping+in+Web+Intelligence 
and a very straightfoward video 
http://www.sdn.sap.com/irj/scn/events?rid=/library/uuid/40ec3a0c-936
                                
                                
Java开发者写SQL时常犯的10个错误
                                    tomcat_oracle
javasql
                                    
1、不用PreparedStatements   　　有意思的是，在JDBC出现了许多年后的今天，这个错误依然出现在博客、论坛和邮件列表中，即便要记住和理解它是一件很简单的事。开发者不使用PreparedStatements的原因可能有如下几个：   　　他们对PreparedStatements不了解   　　他们认为使用PreparedStatements太慢了   　　他们认为写Prepar
                                
                                
世纪互联与结盟有感
                                    阿尔萨斯

                                    
 10月10日，世纪互联与（Foxcon）签约成立合资公司，有感。 
 全球电子制造业巨头（全球500强企业）与世纪互联共同看好IDC、云计算等业务在中国的增长空间，双方迅速果断出手，在资本层面上达成合作，此举体现了全球电子制造业巨头对世纪互联IDC业务的欣赏与信任，另一方面反映出世纪互联目前良好的运营状况与广阔的发展前景。 
 众所周知，精于电子产品制造（世界第一），对于世纪互联而言，能够与结盟
                                
                
            
        
    


    

        

            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    


    

        

            首页 -
            关于我们 -
            站内搜索 -
            Sitemap -
            侵权投诉
        
        
版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.