ServiceStack.OrmLite

Represents the key aspects of a sql operation

The command (sql or a stored-procedure name) to execute

The parameters associated with the command

The active transaction for the command

The effective timeout for the command

The type of command that the command-text represents

Should data be buffered before returning?

Should the plan for this query be cached?

Additional state flags against this command

Can async queries be pipelined?

Initialize the command definition

Additional state flags that control command behaviour

No additional flags

Should data be buffered before returning?

Can async queries be pipelined?

Should the plan cache be bypassed?

Implements custom property mapping by user provided criteria (usually presence of some custom attribute with column to member mapping)

Creates custom property mapping

Target entity type Property selector based on target type and DataReader column name

Always returns default constructor

DataReader column names DataReader column types Default constructor

Always returns null

Not implemented as far as default constructor used for all cases

Returns property based on selector strategy

DataReader column name Poperty member map

This class represents a SQL string, it can be used if you need to denote your parameter is a Char vs VarChar vs nVarChar vs nChar

Default value for IsAnsi.

A value to set the default value of strings going through Dapper. Default is 4000, any value larger than this field will not have the default value applied.

Create a new DbString

Ansi vs Unicode

Fixed length

Length of the string -1 for max

The value of the string

Add the parameter to the command... internal use only

Represents default type mapping strategy used by Dapper

Creates default type map

Entity type

Finds best constructor

DataReader column names DataReader column types Matching constructor or default one

Returns the constructor, if any, that has the ExplicitConstructorAttribute on it.

Gets mapping for constructor parameter

Constructor to resolve DataReader column name Mapping implementation

Gets member mapping for column

DataReader column name Mapping implementation

Should column names like User_Id be allowed to match properties/fields like UserId ?

The settable properties for this typemap

A bag of parameters that can be passed to the Dapper Query and Execute methods

construct a dynamic parameter bag

can be an anonymous type or a DynamicParameters bag

Append a whole object full of params to the dynamic EG: AddDynamicParams(new {A = 1, B = 2}) // will add property A and B to the dynamic

Add a parameter to this dynamic parameter list

If true, the command-text is inspected and only values that are clearly used are included on the connection

Add all the parameters needed to the command just before it executes

The raw command prior to execution Information about the query

All the names of the param in the bag, use Get to yank them out

Get the value of a parameter

The value, note DBNull.Value is not returned, instead the value is returned as null

Allows you to automatically populate a target property/field from output parameters. It actually creates an InputOutput parameter, so you can still pass data in.

The object whose property/field you wish to populate. A MemberExpression targeting a property/field of the target (or descendant thereof.) The size to set on the parameter. Defaults to 0, or DbString.DefaultLength in case of strings. The DynamicParameters instance

Tell Dapper to use an explicit constructor, passing nulls or 0s for all parameters

Handles variances in features per DBMS

Gets the feature set based on the passed connection

True if the db supports array columns e.g. Postgresql

Represents simple member map for one of target parameter or property or field to source DataReader column

Creates instance for simple property mapping

DataReader column name Target property

Creates instance for simple field mapping

DataReader column name Target property

Creates instance for simple constructor parameter mapping

DataReader column name Target constructor parameter

DataReader column name

Target member type

Target property

Target field

Target constructor parameter

Used to pass a IEnumerable<SqlDataRecord> as a SqlDataRecordListTVPParameter

Create a new instance of SqlDataRecordListTVPParameter

Dapper, a light weight object mapper for ADO.NET

Called if the query cache is purged via PurgeQueryCache

Purge the query cache

Return a count of all the cached queries by dapper

Return a list of all the queries cached by dapper

Deep diagnostics only: find any hash collisions in the cache

Clear the registered type handlers

Configure the specified type to be mapped to a given db-type

Configure the specified type to be processed by a custom handler

Get the DbType that maps to a given value

OBSOLETE: For internal usage only. Lookup the DbType and handler for a given Type and member

Obtains the data as a list; if it is *already* a list, the original object is returned without any duplication; otherwise, ToList() is invoked.

Execute parameterized SQL

Number of rows affected

Execute parameterized SQL

Number of rows affected

Execute parameterized SQL that selects a single value

The first cell selected

Execute parameterized SQL that selects a single value

The first cell selected

Execute parameterized SQL that selects a single value

The first cell selected

Execute parameterized SQL that selects a single value

The first cell selected

Execute parameterized SQL and return an

An that can be used to iterate over the results of the SQL query. This is typically used when the results of a query are not processed by Dapper, for example, used to fill a or .

Execute parameterized SQL and return an

An that can be used to iterate over the results of the SQL query. This is typically used when the results of a query are not processed by Dapper, for example, used to fill a or .

Execute parameterized SQL and return an

An that can be used to iterate over the results of the SQL query. This is typically used when the results of a query are not processed by Dapper, for example, used to fill a or .

Return a sequence of dynamic objects with properties matching the columns

Note: each row can be accessed via "dynamic", or by casting to an IDictionary<string,object>

Return a dynamic object with properties matching the columns

Note: the row can be accessed via "dynamic", or by casting to an IDictionary<string,object>

Return a dynamic object with properties matching the columns

Note: the row can be accessed via "dynamic", or by casting to an IDictionary<string,object>

Return a dynamic object with properties matching the columns

Note: the row can be accessed via "dynamic", or by casting to an IDictionary<string,object>

Return a dynamic object with properties matching the columns

Note: the row can be accessed via "dynamic", or by casting to an IDictionary<string,object>

Executes a query, returning the data typed as per T

A sequence of data of the supplied type; if a basic type (int, string, etc) is queried then the data from the first column in assumed, otherwise an instance is created per row, and a direct column-name===member-name mapping is assumed (case insensitive).

Executes a single-row query, returning the data typed as per T

Executes a single-row query, returning the data typed as per the Type suggested

Executes a query, returning the data typed as per T

the dynamic param may seem a bit odd, but this works around a major usability issue in vs, if it is Object vs completion gets annoying. Eg type new [space] get new object A sequence of data of the supplied type; if a basic type (int, string, etc) is queried then the data from the first column in assumed, otherwise an instance is created per row, and a direct column-name===member-name mapping is assumed (case insensitive).

Executes a query, returning the data typed as per T

the dynamic param may seem a bit odd, but this works around a major usability issue in vs, if it is Object vs completion gets annoying. Eg type new [space] get new object A single instance or null of the supplied type; if a basic type (int, string, etc) is queried then the data from the first column in assumed, otherwise an instance is created per row, and a direct column-name===member-name mapping is assumed (case insensitive).

Executes a query, returning the data typed as per T

the dynamic param may seem a bit odd, but this works around a major usability issue in vs, if it is Object vs completion gets annoying. Eg type new [space] get new object A single or null instance of the supplied type; if a basic type (int, string, etc) is queried then the data from the first column in assumed, otherwise an instance is created per row, and a direct column-name===member-name mapping is assumed (case insensitive).

Executes a query, returning the data typed as per T

the dynamic param may seem a bit odd, but this works around a major usability issue in vs, if it is Object vs completion gets annoying. Eg type new [space] get new object A single instance of the supplied type; if a basic type (int, string, etc) is queried then the data from the first column in assumed, otherwise an instance is created per row, and a direct column-name===member-name mapping is assumed (case insensitive).

Executes a query, returning the data typed as per T

the dynamic param may seem a bit odd, but this works around a major usability issue in vs, if it is Object vs completion gets annoying. Eg type new [space] get new object A single instance of the supplied type; if a basic type (int, string, etc) is queried then the data from the first column in assumed, otherwise an instance is created per row, and a direct column-name===member-name mapping is assumed (case insensitive).

Execute a command that returns multiple result sets, and access each in turn

Maps a query to objects

The first type in the record set The second type in the record set The return type The Field we should split and read the second object from (default: id) Number of seconds before command execution timeout Is it a stored proc or a batch?

Maps a query to objects

The Field we should split and read the second object from (default: id) Number of seconds before command execution timeout

Perform a multi mapping query with 4 input parameters

Perform a multi mapping query with 5 input parameters

Perform a multi mapping query with 6 input parameters

Perform a multi mapping query with 7 input parameters

Perform a multi mapping query with arbitrary input parameters

The return type array of types in the record set The Field we should split and read the second object from (default: id) Number of seconds before command execution timeout Is it a stored proc or a batch?

Internal use only

OBSOLETE: For internal usage only. Sanitizes the paramter value with proper type casting.

Replace all literal tokens with their text form

Convert numeric values to their string form for SQL literal purposes

Internal use only

Gets type-map for the given type

Type map instance, default is to create new instance of DefaultTypeMap

Gets type-map for the given type

Type map implementation, DefaultTypeMap instance if no override present

Set custom mapping for type deserializers

Entity type to override Mapping rules impementation, null to remove custom map

Internal use only

Throws a data exception, only used internally

How should connection strings be compared for equivalence? Defaults to StringComparer.Ordinal. Providing a custom implementation can be useful for allowing multi-tenancy databases with identical schema to share strategies. Note that usual equivalence rules apply: any equivalent connection strings MUST yield the same hash-code.

Key used to indicate the type name associated with a DataTable

Used to pass a DataTable as a TableValuedParameter

Associate a DataTable with a type name

Fetch the type name associated with a DataTable

Used to pass a IEnumerable<SqlDataRecord> as a TableValuedParameter

Dummy type for excluding from multi-map

The grid reader provides interfaces for reading multiple result sets from a Dapper query

Read the next grid of results, returned as a dynamic object

Note: each row can be accessed via "dynamic", or by casting to an IDictionary<string,object>

Read an individual row of the next grid of results, returned as a dynamic object

Note: the row can be accessed via "dynamic", or by casting to an IDictionary<string,object>

Read an individual row of the next grid of results, returned as a dynamic object

Note: the row can be accessed via "dynamic", or by casting to an IDictionary<string,object>

Read an individual row of the next grid of results, returned as a dynamic object

Note: the row can be accessed via "dynamic", or by casting to an IDictionary<string,object>

Read an individual row of the next grid of results, returned as a dynamic object

Note: the row can be accessed via "dynamic", or by casting to an IDictionary<string,object>

Read the next grid of results

Read an individual row of the next grid of results

Read the next grid of results

Read an individual row of the next grid of results

Read multiple objects from a single record set on the grid

Has the underlying reader been consumed?

The command associated with the reader

Dispose the grid, closing and disposing both the underlying reader and command.

Implement this interface to pass an arbitrary db specific parameter to Dapper

Add the parameter needed to the command before it executes

The raw command prior to execution Parameter name

Parses a data reader to a sequence of data of the supplied type. Used for deserializing a reader without a connection, etc.

Parses a data reader to a sequence of data of the supplied type (as object). Used for deserializing a reader without a connection, etc.

Parses a data reader to a sequence of dynamic. Used for deserializing a reader without a connection, etc.

Gets the row parser for a specific row on a data reader. This allows for type switching every row based on, for example, a TypeId column. You could return a collection of the base type but have each more specific.

The data reader to get the parser for the current row from The type to get the parser for The start column index of the object (default 0) The length of columns to read (default -1 = all fields following startIndex) Return null if we can't find the first column? (default false) A parser for this specific object from this row. var result = new List<BaseType>(); using (var reader = connection.ExecuteReader(@" select 'abc' as Name, 1 as Type, 3.0 as Value union all select 'def' as Name, 2 as Type, 4.0 as Value")) { if (reader.Read()) { var toFoo = reader.GetRowParser<BaseType>(typeof(Foo)); var toBar = reader.GetRowParser<BaseType>(typeof(Bar)); var col = reader.GetOrdinal("Type"); do { switch (reader.GetInt32(col)) { case 1: result.Add(toFoo(reader)); break; case 2: result.Add(toBar(reader)); break; } } while (reader.Read()); } } abstract class BaseType { public abstract int Type { get; } } class Foo : BaseType { public string Name { get; set; } public override int Type => 1; } class Bar : BaseType { public float Value { get; set; } public override int Type => 2; }

Identity of a cached query in Dapper, used for extensibility

Create an identity for use with DynamicParameters, internal use only

The sql

The command type

Compare 2 Identity objects

Implement this interface to pass an arbitrary db specific set of parameters to Dapper

Add all the parameters needed to the command just before it executes

The raw command prior to execution Information about the query

Implements this interface to provide custom member mapping

Source DataReader column name

Target member type

Target property

Target field

Target constructor parameter

Extends IDynamicParameters with facilities for executing callbacks after commands have completed

Invoked when the command has executed

Extends IDynamicParameters providing by-name lookup of parameter values

Get the value of the specified parameter (return null if not found)

Implement this interface to perform custom type-based parameter handling and value parsing

Assign the value of a parameter before a command executes

The parameter to configure Parameter value

Parse a database value back to a typed value

The value from the database The type to parse to The typed value

Implement this interface to change default mapping of reader columns to type members

Finds best constructor

DataReader column names DataReader column types Matching constructor or default one

Returns a constructor which should *always* be used. Parameters will be default values, nulls for reference types and zero'd for value types. Use this class to force object creation away from parameterless constructors you don't control.

Gets mapping for constructor parameter

Constructor to resolve DataReader column name Mapping implementation

Gets member mapping for column

DataReader column name Mapping implementation

This is a micro-cache; suitable when the number of terms is controllable (a few hundred, for example), and strictly append-only; you cannot change existing values. All key matches are on **REFERENCE** equality. The type is fully thread-safe.

Represents a placeholder for a value that should be replaced as a literal value in the resulting sql

The text in the original command that should be replaced

The name of the member referred to by the token

Permits specifying certain SqlMapper values globally.

Resets all Settings to their default values

Specifies the default Command Timeout for all Queries

Indicates whether nulls in data are silently ignored (default) vs actively applied and assigned to members

Should list expansions be padded with null-valued parameters, to prevent query-plan saturation? For example, an 'in @foo' expansion with 7, 8 or 9 values will be sent as a list of 10 values, with 3, 2 or 1 of them null. The padding size is relative to the size of the list; "next 10" under 150, "next 50" under 500, "next 100" under 1500, etc.

Caution: this should be treated with care if your DB provider (or the specific configuration) allows for null equality (aka "ansi nulls off"), as this may change the intent of your query; as such, this is disabled by default and must be enabled.

Base-class for simple type-handlers

Assign the value of a parameter before a command executes

The parameter to configure Parameter value

Parse a database value back to a typed value

The value from the database The typed value

Base-class for simple type-handlers that are based around strings

Parse a string into the expected type (the string will never be null)

Format an instace into a string (the instance will never be null)

Assign the value of a parameter before a command executes

The parameter to configure Parameter value

Parse a database value back to a typed value

The value from the database The typed value

Not intended for direct usage

A type handler for data-types that are supported by the underlying provider, but which need a well-known UdtTypeName to be specified

Creates a new instance of UdtTypeHandler with the specified UdtTypeName

Used to pass a DataTable as a TableValuedParameter

Create a new instance of TableValuedParameter

Describes a reader that controls the lifetime of both a command and a reader, exposing the downstream command/reader as properties.

Obtain the underlying reader

Obtain the underlying command

RDBMS Dialect this Converter is for. Injected at registration.

SQL Column Definiton used in CREATE Table.

Used in DB Params. Defaults to DbType.String

Quoted Value in SQL Statement

Customize how DB Param is initialized. Useful for supporting RDBMS-specific Types.

Parameterized value in parameterized queries

Value from DB to Populate on POCO Data Model with

Retrieve Value from ADO.NET IDataReader. Defaults to reader.GetValue()

For Types that are natively supported by RDBMS's and shouldn't be quoted

Returns results from using an SqlFormat query. E.g: db.SelectFmt<Person>("Age > {0}", 40) db.SelectFmt<Person>("SELECT * FROM Person WHERE Age > {0}", 40)

Returns a partial subset of results from the specified tableType using a SqlFormat query. E.g: db.SelectFmt<EntityWithId>(typeof(Person), "Age > {0}", 40)

Returns a lazyily loaded stream of results using an SqlFilter query. E.g: db.SelectLazyFmt<Person>("Age > {0}", 40)

Returns the first result using a SqlFormat query. E.g: db.SingleFmt<Person>("Age = {0}", 42)

Returns a single scalar value using an SqlFormat query. E.g: db.ScalarFmt<int>("SELECT COUNT(*) FROM Person WHERE Age > {0}", 40)

Returns the first column in a List using a SqlFormat query. E.g: db.ColumnFmt<string>("SELECT LastName FROM Person WHERE Age = {0}", 27)

Returns the distinct first column values in a HashSet using an SqlFormat query. E.g: db.ColumnDistinctFmt<int>("SELECT Age FROM Person WHERE Age < {0}", 50)

Returns an Dictionary<K, List<V>> grouping made from the first two columns using an SqlFormat query. E.g: db.LookupFmt<int, string>("SELECT Age, LastName FROM Person WHERE Age < {0}", 50)

Returns a Dictionary from the first 2 columns: Column 1 (Keys), Column 2 (Values) using an SqlFormat query. E.g: db.DictionaryFmt<int, string>("SELECT Id, LastName FROM Person WHERE Age < {0}", 50)

Returns true if the Query returns any records, using an SqlFormat query. E.g: db.ExistsFmt<Person>("Age = {0}", 42) db.ExistsFmt<Person>("SELECT * FROM Person WHERE Age = {0}", 50)

Returns true if the Query returns any records that match the SqlExpression lambda, E.g: db.Exists<Person>(q => q.Where(x => x.Age < 50))

Create a new SqlExpression builder allowing typed LINQ-like queries.

Returns results from using an SqlExpression lambda. E.g: db.Select<Person>(q => q.Where(x => x.Age > 40))

Project results from a number of joined tables into a different model

Returns a single result from using an SqlExpression lambda. E.g: db.Single<Person>(q => q.Where(x => x.Age == 42))

Returns the count of rows that match the SqlExpression lambda, E.g: db.Count<Person>(q => q.Where(x => x.Age < 50))

Returns results with references from using an SqlExpression lambda. E.g: db.LoadSelect<Person>(q => q.Where(x => x.Age > 40))

Returns results with references from using an SqlExpression lambda. E.g: db.LoadSelect<Person>(q => q.Where(x => x.Age > 40), include: x => new { x.PrimaryAddress })

Delete rows using a SqlFormat filter. E.g: db.Delete<Person>("Age > {0}", 42)

number of rows deleted

Delete rows from the runtime table type using a SqlFormat filter. E.g:

db.DeleteFmt(typeof(Person), "Age = {0}", 27) number of rows deleted

Insert only fields in POCO specified by the SqlExpression lambda. E.g: db.InsertOnly(new Person { FirstName = "Amy", Age = 27 }, q => q.Insert(p => new { p.FirstName, p.Age }))

Use an SqlExpression to select which fields to update and construct the where expression, E.g: db.UpdateOnly(new Person { FirstName = "JJ" }, ev => ev.Update(p => p.FirstName).Where(x => x.FirstName == "Jimi")); UPDATE "Person" SET "FirstName" = 'JJ' WHERE ("FirstName" = 'Jimi') What's not in the update expression doesn't get updated. No where expression updates all rows. E.g: db.UpdateOnly(new Person { FirstName = "JJ", LastName = "Hendo" }, ev => ev.Update(p => p.FirstName)); UPDATE "Person" SET "FirstName" = 'JJ'

Flexible Update method to succinctly execute a free-text update statement using optional params. E.g: db.Update<Person>(set:"FirstName = {0}".Params("JJ"), where:"LastName = {0}".Params("Hendrix")); UPDATE "Person" SET FirstName = 'JJ' WHERE LastName = 'Hendrix'

Flexible Update method to succinctly execute a free-text update statement using optional params. E.g. db.Update(table:"Person", set: "FirstName = {0}".Params("JJ"), where: "LastName = {0}".Params("Hendrix")); UPDATE "Person" SET FirstName = 'JJ' WHERE LastName = 'Hendrix'

Flexible Delete method to succinctly execute a delete statement using free-text where expression. E.g. db.Delete<Person>(where:"Age = {0}".Params(27)); DELETE FROM "Person" WHERE Age = 27

Flexible Delete method to succinctly execute a delete statement using free-text where expression. E.g. db.Delete(table:"Person", where: "Age = {0}".Params(27)); DELETE FROM "Person" WHERE Age = 27

Delete the rows that matches the where expression, e.g: db.Delete<Person>(ev => ev.Where(p => p.Age == 27)); DELETE FROM "Person" WHERE ("Age" = 27)

Using an SqlExpression to only Insert the fields specified, e.g: db.InsertOnly(new Person { FirstName = "Amy" }, q => q.Insert(p => new { p.FirstName })); INSERT INTO "Person" ("FirstName") VALUES ('Amy');

Tell ServiceStack to use ThreadStatic Items Collection for Context Scoped items. Warning: ThreadStatic Items aren't pinned to the same request in async services which callback on different threads.

Gets a list of items for this context.

Clear select expression. All properties will be selected.

set the specified selectExpression.

raw Select expression: "Select SomeField1, SomeField2 from SomeTable"

Set the specified selectExpression using matching fields.

Matching Fields: "SomeField1, SomeField2"

Offset of the first row to return. The offset of the initial row is 0

Number of rows returned by a SELECT statement

Set the specified offset and rows for SQL Limit clause.

Offset of the first row to return. The offset of the initial row is 0 Number of rows returned by a SELECT statement

Set the specified offset and rows for SQL Limit clause where they exist.

Offset of the first row to return. The offset of the initial row is 0 Number of rows returned by a SELECT statement

Set the specified rows for Sql Limit clause.

Number of rows returned by a SELECT statement

Clear Sql Limit clause

Clear Offset and Limit clauses. Alias for Limit()

Fields to be updated.

List<string> containing Names of properties to be updated

Fields to be updated.

IEnumerable<string> containing Names of properties to be updated

Fields to be updated.

x=> x.SomeProperty1 or x=> new { x.SomeProperty1, x.SomeProperty2 }

Clear UpdateFields list ( all fields will be updated)

Fields to be inserted.

x=> x.SomeProperty1 or x=> new{ x.SomeProperty1, x.SomeProperty2} objectWithProperties

fields to be inserted.

IList<string> containing Names of properties to be inserted

Clear InsertFields list ( all fields will be inserted)

Enables the efficient, dynamic composition of query predicates.

Creates a predicate that evaluates to true.

Creates a predicate that evaluates to false.

Creates a predicate expression from the specified lambda expression.

Combines the first predicate with the second using the logical "and".

Combines the first predicate with the second using the logical "or".

Negates the predicate.

Combines the first expression with the second using the specified merge function.

Creates a new SqlExpression builder allowing typed LINQ-like queries. Alias for SqlExpression.

Creates a new SqlExpression builder for the specified type using a user-defined FROM sql expression.

Open a Transaction in OrmLite

Create a managed OrmLite IDbCommand

Returns results from using a LINQ Expression. E.g: db.Select<Person>(x => x.Age > 40)

Returns results from using an SqlExpression lambda. E.g: db.Select(db.From<Person>().Where(x => x.Age > 40))

Returns a single result from using a LINQ Expression. E.g: db.Single<Person>(x => x.Age == 42)

Returns results from using an SqlExpression lambda. E.g: db.Select<Person>(x => x.Age > 40)

Returns results from using an SqlExpression lambda. E.g: db.Single(db.From<Person>().Where(x => x.Age > 40))

Returns a scalar result from using an SqlExpression lambda. E.g: db.Scalar<Person, int>(x => Sql.Max(x.Age))

Returns a scalar result from using an SqlExpression lambda. E.g: db.Scalar<Person, int>(x => Sql.Max(x.Age), , x => x.Age < 50)

Returns the count of rows that match the LINQ expression, E.g: db.Count<Person>(x => x.Age < 50)

Returns the count of rows that match the supplied SqlExpression, E.g: db.Count(db.From<Person>().Where(x => x.Age < 50))

Return the number of rows returned by the supplied expression

Return the number of rows returned by the supplied sql

Return the number of rows returned by the supplied sql and db params

Returns results with references from using a LINQ Expression. E.g: db.LoadSelect<Person>(x => x.Age > 40)

Returns results with references from using a LINQ Expression. E.g: db.LoadSelect<Person>(x => x.Age > 40, include: x => new { x.PrimaryAddress })

Returns results with references from using an SqlExpression lambda. E.g: db.LoadSelect(db.From<Person>().Where(x => x.Age > 40))

Returns results with references from using an SqlExpression lambda. E.g: db.LoadSelect(db.From<Person>().Where(x => x.Age > 40), include:q.OnlyFields)

Returns results with references from using an SqlExpression lambda. E.g: db.LoadSelect(db.From<Person>().Where(x => x.Age > 40), include: x => new { x.PrimaryAddress })

Project results with references from a number of joined tables into a different model

Use an SqlExpression to select which fields to update and construct the where expression, E.g: var q = db.From>Person<()); db.UpdateOnly(new Person { FirstName = "JJ" }, q.Update(p => p.FirstName).Where(x => x.FirstName == "Jimi")); UPDATE "Person" SET "FirstName" = 'JJ' WHERE ("FirstName" = 'Jimi') What's not in the update expression doesn't get updated. No where expression updates all rows. E.g: db.UpdateOnly(new Person { FirstName = "JJ", LastName = "Hendo" }, ev.Update(p => p.FirstName)); UPDATE "Person" SET "FirstName" = 'JJ'

Update only fields in the specified expression that matches the where condition (if any), E.g: db.UpdateOnly(() => new Person { FirstName = "JJ" }, where: p => p.LastName == "Hendrix"); UPDATE "Person" SET "FirstName" = 'JJ' WHERE ("LastName" = 'Hendrix') db.UpdateOnly(() => new Person { FirstName = "JJ" }); UPDATE "Person" SET "FirstName" = 'JJ'

Update only fields in the specified expression that matches the where condition (if any), E.g: db.UpdateOnly(() => new Person { FirstName = "JJ" }, db.From>Person<().Where(p => p.LastName == "Hendrix")); UPDATE "Person" SET "FirstName" = 'JJ' WHERE ("LastName" = 'Hendrix')

Update record, updating only fields specified in updateOnly that matches the where condition (if any), E.g: db.UpdateOnly(new Person { FirstName = "JJ" }, p => p.FirstName, p => p.LastName == "Hendrix"); UPDATE "Person" SET "FirstName" = 'JJ' WHERE ("LastName" = 'Hendrix') db.UpdateOnly(new Person { FirstName = "JJ" }, p => p.FirstName); UPDATE "Person" SET "FirstName" = 'JJ' db.UpdateOnly(new Person { FirstName = "JJ", Age = 27 }, p => new { p.FirstName, p.Age ); UPDATE "Person" SET "FirstName" = 'JJ', "Age" = 27

Update record, updating only fields specified in updateOnly that matches the where condition (if any), E.g: db.UpdateOnly(new Person { FirstName = "JJ" }, new[]{ "FirstName" }, p => p.LastName == "Hendrix"); UPDATE "Person" SET "FirstName" = 'JJ' WHERE ("LastName" = 'Hendrix')

Update record, updating only fields specified in updateOnly that matches the where condition (if any), E.g: Numeric fields generates an increment sql which is usefull to increment counters, etc... avoiding concurrency conflicts db.UpdateAdd(() => new Person { Age = 5 }, where: p => p.LastName == "Hendrix"); UPDATE "Person" SET "Age" = "Age" + 5 WHERE ("LastName" = 'Hendrix') db.UpdateAdd(() => new Person { Age = 5 }); UPDATE "Person" SET "Age" = "Age" + 5

Update record, updating only fields specified in updateOnly that matches the where condition (if any), E.g: Numeric fields generates an increment sql which is usefull to increment counters, etc... avoiding concurrency conflicts db.UpdateAdd(() => new Person { Age = 5 }, db.From<Person>().Where(p => p.LastName == "Hendrix")); UPDATE "Person" SET "Age" = "Age" + 5 WHERE ("LastName" = 'Hendrix')

Updates all non-default values set on item matching the where condition (if any). E.g db.UpdateNonDefaults(new Person { FirstName = "JJ" }, p => p.FirstName == "Jimi"); UPDATE "Person" SET "FirstName" = 'JJ' WHERE ("FirstName" = 'Jimi')

Updates all values set on item matching the where condition (if any). E.g db.Update(new Person { Id = 1, FirstName = "JJ" }, p => p.LastName == "Hendrix"); UPDATE "Person" SET "Id" = 1,"FirstName" = 'JJ',"LastName" = NULL,"Age" = 0 WHERE ("LastName" = 'Hendrix')

Updates all matching fields populated on anonymousType that matches where condition (if any). E.g: db.Update<Person>(new { FirstName = "JJ" }, p => p.LastName == "Hendrix"); UPDATE "Person" SET "FirstName" = 'JJ' WHERE ("LastName" = 'Hendrix')

Using an SqlExpression to only Insert the fields specified, e.g: db.InsertOnly(new Person { FirstName = "Amy" }, p => p.FirstName)); INSERT INTO "Person" ("FirstName") VALUES ('Amy'); db.InsertOnly(new Person { Id =1 , FirstName="Amy" }, p => new { p.Id, p.FirstName })); INSERT INTO "Person" ("Id", "FirstName") VALUES (1, 'Amy');

Using an SqlExpression to only Insert the fields specified, e.g: db.InsertOnly(new Person { FirstName = "Amy" }, new[]{ "FirstName" })); INSERT INTO "Person" ("FirstName") VALUES ('Amy');

Using an SqlExpression to only Insert the fields specified, e.g: db.InsertOnly(() => new Person { FirstName = "Amy" })); INSERT INTO "Person" ("FirstName") VALUES (@FirstName);

Delete the rows that matches the where expression, e.g: db.Delete<Person>(p => p.Age == 27); DELETE FROM "Person" WHERE ("Age" = 27)

Delete the rows that matches the where expression, e.g: var q = db.From<Person>()); db.Delete<Person>(q.Where(p => p.Age == 27)); DELETE FROM "Person" WHERE ("Age" = 27)

Returns results from the active connection.

Returns results from using sql. E.g: db.Select<Person>("Age > 40") db.Select<Person>("SELECT * FROM Person WHERE Age > 40")

Returns results from using sql. E.g: db.Select<Person>("SELECT * FROM Person WHERE Age > @age", new[] { db.CreateParam("age", 40) })

Returns results from using a parameterized query. E.g: db.Select<Person>("Age > @age", new { age = 40}) db.Select<Person>("SELECT * FROM Person WHERE Age > @age", new { age = 40})

Returns results from using a parameterized query. E.g: db.Select<Person>("Age > @age", new Dictionary<string, object> { { "age", 40 } }) db.Select<Person>("SELECT * FROM Person WHERE Age > @age", new Dictionary<string, object> { { "age", 40 } })

Returns a partial subset of results from the specified tableType. E.g: db.Select<EntityWithId>(typeof(Person))

Returns results from using a single name, value filter. E.g: db.Where<Person>("Age", 27)

Returns results from using an anonymous type filter. E.g: db.Where<Person>(new { Age = 27 })

Returns results using the supplied primary key ids. E.g: db.SelectByIds<Person>(new[] { 1, 2, 3 })

Query results using the non-default values in the supplied partially populated POCO example. E.g: db.SelectNonDefaults(new Person { Id = 1 })

Query results using the non-default values in the supplied partially populated POCO example. E.g: db.SelectNonDefaults("Age > @Age", new Person { Age = 42 })

Returns a lazyily loaded stream of results. E.g: db.SelectLazy<Person>()

Returns a lazyily loaded stream of results using a parameterized query. E.g: db.SelectLazy<Person>("Age > @age", new { age = 40 })

Returns a lazyily loaded stream of results using a parameterized query. E.g: db.SelectLazy(db.From<Person>().Where(x => x == 40))

Returns a stream of results that are lazily loaded using a parameterized query. E.g: db.WhereLazy<Person>(new { Age = 27 })

Returns the first result using a parameterized query. E.g: db.Single<Person>(new { Age = 42 })

Returns results from using a single name, value filter. E.g: db.Single<Person>("Age = @age", new[] { db.CreateParam("age",40) })

Returns results from using a single name, value filter. E.g: db.Single<Person>("Age = @age", new { age = 42 })

Returns the first result using a primary key id. E.g: db.SingleById<Person>(1)

Returns the first result using a name, value filter. E.g: db.SingleWhere<Person>("Age", 42)

Returns a single scalar value using an SqlExpression. E.g: db.Column<int>(db.From<Persion>().Select(x => Sql.Count("*")).Where(q => q.Age > 40))

Returns a single scalar value using a parameterized query. E.g: db.Scalar<int>("SELECT COUNT(*) FROM Person WHERE Age > @age", new[] { db.CreateParam("age",40) })

Returns a single scalar value using a parameterized query. E.g: db.Scalar<int>("SELECT COUNT(*) FROM Person WHERE Age > @age", new { age = 40 })

Returns the distinct first column values in a HashSet using an SqlExpression. E.g: db.Column<int>(db.From<Persion>().Select(x => x.LastName).Where(q => q.Age == 27))

Returns the first column in a List using a SqlFormat query. E.g: db.Column<string>("SELECT LastName FROM Person WHERE Age = @age", new[] { db.CreateParam("age",27) })

Returns the distinct first column values in a HashSet using an SqlExpression. E.g: db.ColumnLazy<int>(db.From<Persion>().Select(x => x.LastName).Where(q => q.Age == 27))

Returns the first column in a List using a SqlFormat query. E.g: db.ColumnLazy<string>("SELECT LastName FROM Person WHERE Age = @age", new[] { db.CreateParam("age",27) })

Returns the first column in a List using a SqlFormat query. E.g: db.ColumnLazy<string>("SELECT LastName FROM Person WHERE Age = @age", new { age = 27 })

Returns the first column in a List using a SqlFormat query. E.g: db.Column<string>("SELECT LastName FROM Person WHERE Age = @age", new { age = 27 })

Returns the distinct first column values in a HashSet using an SqlFormat query. E.g: db.ColumnDistinct<int>("SELECT Age FROM Person WHERE Age < @age", new { age = 50 })

Returns the distinct first column values in a HashSet using an SqlFormat query. E.g: db.ColumnDistinct<int>("SELECT Age FROM Person WHERE Age < @age", new[] { db.CreateParam("age",50) })

Returns an Dictionary<K, List<V>> grouping made from the first two columns using an parameterized query. E.g: db.Lookup<int, string>("SELECT Age, LastName FROM Person WHERE Age < @age", new[] { db.CreateParam("age",50) })

Returns a Dictionary from the first 2 columns: Column 1 (Keys), Column 2 (Values) using sql. E.g: db.Dictionary<int, string>("SELECT Id, LastName FROM Person WHERE Age < @age", new { age = 50 })

Returns true if the Query returns any records that match the LINQ expression, E.g: db.Exists<Person>(x => x.Age < 50)

Returns true if the Query returns any records that match the supplied SqlExpression, E.g: db.Exists(db.From<Person>().Where(x => x.Age < 50))

Returns true if the Query returns any records, using an SqlFormat query. E.g: db.Exists<Person>(new { Age = 42 })

Returns true if the Query returns any records, using a parameterized query. E.g: db.Exists<Person>("Age = @age", new { age = 42 }) db.Exists<Person>("SELECT * FROM Person WHERE Age = @age", new { age = 42 })

Returns results from an arbitrary SqlExpression. E.g: db.SqlList<Person>(db.From<Person>().Select("*").Where(q => q.Age < 50))

Returns results from an arbitrary parameterized raw sql query. E.g: db.SqlList<Person>("EXEC GetRockstarsAged @age", new[] { db.CreateParam("age",50) })

Returns results from an arbitrary parameterized raw sql query. E.g: db.SqlList<Person>("EXEC GetRockstarsAged @age", new { age = 50 })

Returns results from an arbitrary parameterized raw sql query. E.g: db.SqlList<Person>("EXEC GetRockstarsAged @age", new Dictionary<string, object> { { "age", 42 } })

Returns results from an arbitrary parameterized raw sql query with a dbCmd filter. E.g: db.SqlList<Person>("EXEC GetRockstarsAged @age", dbCmd => ...)

Prepare Stored Procedure with Input parameters, optionally populated with Input Params. E.g: var cmd = db.SqlProc("GetRockstarsAged", new { age = 42 })

Returns the first column in a List using a parameterized query. E.g: db.SqlColumn<string>("SELECT LastName FROM Person WHERE Age < @age", new[] { db.CreateParam("age",50) })

Returns the first column in a List using a parameterized query. E.g: db.SqlColumn<string>("SELECT LastName FROM Person WHERE Age < @age", new { age = 50 })

Returns the first column in a List using a parameterized query. E.g: db.SqlColumn<string>("SELECT LastName FROM Person WHERE Age < @age", new Dictionary<string, object> { { "age", 50 } })

Returns a single Scalar value using an SqlExpression. E.g: db.SqlScalar<int>(db.From<Person>().Select(Sql.Count("*")).Where(q => q.Age < 50))

Returns a single Scalar value using a parameterized query. E.g: db.SqlScalar<int>("SELECT COUNT(*) FROM Person WHERE Age < @age", new[]{ db.CreateParam("age",50) })

Returns a single Scalar value using a parameterized query. E.g: db.SqlScalar<int>("SELECT COUNT(*) FROM Person WHERE Age < @age", new { age = 50 })

Returns a single Scalar value using a parameterized query. E.g: db.SqlScalar<int>("SELECT COUNT(*) FROM Person WHERE Age < @age", new Dictionary<string, object> { { "age", 50 } })

Returns the last insert Id made from this connection.

Executes a raw sql non-query using sql. E.g: var rowsAffected = db.ExecuteNonQuery("UPDATE Person SET LastName={0} WHERE Id={1}".SqlFormat("WaterHouse", 7))

number of rows affected

Executes a raw sql non-query using a parameterized query. E.g: var rowsAffected = db.ExecuteNonQuery("UPDATE Person SET LastName=@name WHERE Id=@id", new { name = "WaterHouse", id = 7 })

number of rows affected

Executes a raw sql non-query using a parameterized query.

number of rows affected

Returns results from a Stored Procedure, using a parameterized query.

Returns results from a Stored Procedure using an SqlFormat query. E.g:

Returns the scalar result as a long.

Returns the first result with all its references loaded, using a primary key id. E.g: db.LoadSingleById<Person>(1, include = new[]{ "Address" })

Returns the first result with all its references loaded, using a primary key id. E.g: db.LoadSingleById<Person>(1, include = x => new{ x.Address })

Loads all the related references onto the instance. E.g: db.LoadReferences(customer)

Checks whether a Table Exists. E.g: db.TableExists("Person")

Checks whether a Table Exists. E.g: db.TableExists<Person>()

Checks whether a Table Column Exists. E.g: db.ColumnExists("Age", "Person")

Checks whether a Table Column Exists. E.g: db.ColumnExists<Person>(x => x.Age)

Create DB Tables from the schemas of runtime types. E.g: db.CreateTables(typeof(Table1), typeof(Table2))

Create DB Table from the schema of the runtime type. Use overwrite to drop existing Table. E.g: db.CreateTable(true, typeof(Table))

Only Create new DB Tables from the schemas of runtime types if they don't already exist. E.g: db.CreateTableIfNotExists(typeof(Table1), typeof(Table2))

Drop existing DB Tables and re-create them from the schemas of runtime types. E.g: db.DropAndCreateTables(typeof(Table1), typeof(Table2))

Create a DB Table from the generic type. Use overwrite to drop the existing table or not. E.g: db.CreateTable<Person>(overwrite=false) //default db.CreateTable<Person>(overwrite=true)

Only create a DB Table from the generic type if it doesn't already exist. E.g: db.CreateTableIfNotExists<Person>()

Only create a DB Table from the runtime type if it doesn't already exist. E.g: db.CreateTableIfNotExists(typeof(Person))

Drop existing table if exists and re-create a DB Table from the generic type. E.g: db.DropAndCreateTable<Person>()

Drop existing table if exists and re-create a DB Table from the runtime type. E.g: db.DropAndCreateTable(typeof(Person))

Drop any existing tables from their runtime types. E.g: db.DropTables(typeof(Table1),typeof(Table2))

Drop any existing tables from the runtime type. E.g: db.DropTable(typeof(Person))

Drop any existing tables from the generic type. E.g: db.DropTable<Person>()

Get the last SQL statement that was executed.

Execute any arbitrary raw SQL.

number of rows affected

Execute any arbitrary raw SQL with db params.

number of rows affected

Insert 1 POCO, use selectIdentity to retrieve the last insert AutoIncrement id (if any). E.g: var id = db.Insert(new Person { Id = 1, FirstName = "Jimi }, selectIdentity:true)

Insert 1 or more POCOs in a transaction. E.g: db.Insert(new Person { Id = 1, FirstName = "Tupac", LastName = "Shakur", Age = 25 }, new Person { Id = 2, FirstName = "Biggie", LastName = "Smalls", Age = 24 })

Insert a collection of POCOs in a transaction. E.g: db.InsertAll(new[] { new Person { Id = 9, FirstName = "Biggie", LastName = "Smalls", Age = 24 } })

Updates 1 POCO. All fields are updated except for the PrimaryKey which is used as the identity selector. E.g: db.Update(new Person { Id = 1, FirstName = "Jimi", LastName = "Hendrix", Age = 27 })

Updates 1 or more POCOs in a transaction. E.g: db.Update(new Person { Id = 1, FirstName = "Tupac", LastName = "Shakur", Age = 25 }, new Person { Id = 2, FirstName = "Biggie", LastName = "Smalls", Age = 24 })

Updates 1 or more POCOs in a transaction. E.g: db.UpdateAll(new[] { new Person { Id = 1, FirstName = "Jimi", LastName = "Hendrix", Age = 27 } })

Delete rows using an anonymous type filter. E.g: db.Delete<Person>(new { FirstName = "Jimi", Age = 27 })

number of rows deleted

Delete 1 row using all fields in the filter. E.g: db.Delete(new Person { Id = 1, FirstName = "Jimi", LastName = "Hendrix", Age = 27 })

number of rows deleted

Delete 1 or more rows in a transaction using all fields in the filter. E.g: db.Delete(new Person { Id = 1, FirstName = "Jimi", LastName = "Hendrix", Age = 27 })

Delete 1 or more rows using only field with non-default values in the filter. E.g: db.DeleteNonDefaults(new Person { FirstName = "Jimi", Age = 27 })

number of rows deleted

Delete 1 or more rows in a transaction using only field with non-default values in the filter. E.g: db.DeleteNonDefaults(new Person { FirstName = "Jimi", Age = 27 }, new Person { FirstName = "Janis", Age = 27 })

number of rows deleted

Delete 1 row by the PrimaryKey. E.g: db.DeleteById<Person>(1)

number of rows deleted

Delete 1 row by the PrimaryKey where the rowVersion matches the optimistic concurrency field. Will throw RowModefiedExeption if the row does not exist or has a different row version. E.g: db.DeleteById<Person>(1)

Delete all rows identified by the PrimaryKeys. E.g: db.DeleteById<Person>(new[] { 1, 2, 3 })

number of rows deleted

Delete all rows in the generic table type. E.g: db.DeleteAll<Person>()

number of rows deleted

Delete all rows provided. E.g: db.DeleteAll<Person>(people)

number of rows deleted

Delete all rows in the runtime table type. E.g: db.DeleteAll(typeof(Person))

number of rows deleted

Delete rows using a SqlFormat filter. E.g: db.Delete<Person>("Age > @age", new { age = 42 })

number of rows deleted

Delete rows using a SqlFormat filter. E.g: db.Delete<Person>("Age > @age", new { age = 42 })

number of rows deleted

Insert a new row or update existing row. Returns true if a new row was inserted. Optional references param decides whether to save all related references as well. E.g: db.Save(customer, references:true)

true if a row was inserted; false if it was updated

Insert new rows or update existing rows. Return number of rows added E.g: db.Save(new Person { Id = 10, FirstName = "Amy", LastName = "Winehouse", Age = 27 })

number of rows added

Insert new rows or update existing rows. Return number of rows added E.g: db.SaveAll(new [] { new Person { Id = 10, FirstName = "Amy", LastName = "Winehouse", Age = 27 } })

number of rows added

Populates all related references on the instance with its primary key and saves them. Uses '(T)Id' naming convention. E.g: db.SaveAllReferences(customer)

Populates the related references with the instance primary key and saves them. Uses '(T)Id' naming convention. E.g: db.SaveReference(customer, customer.Orders)

Populates the related references with the instance primary key and saves them. Uses '(T)Id' naming convention. E.g: db.SaveReferences(customer, customer.Orders)

Wrapper IDbConnection class to allow for connection sharing, mocking, etc.

Allow for mocking and unit testing by providing non-disposing connection factory with injectable IDbCommand and IDbTransaction proxies

Force the IDbConnection to always return this IDbCommand

Force the IDbConnection to always return this IDbTransaction

Alias for OpenDbConnection

Allow for code-sharing between OrmLite, IPersistenceProvider and ICacheClient

Gets the explicit Converter registered for a specific type

Return best matching converter, falling back to Enum, Value or Ref Type Converters

Quote the string so that it can be used inside an SQL-expression Escape quotes inside the string

Nice SqlBuilder class by @samsaffron from Dapper.Contrib: http://samsaffron.com/archive/2011/09/05/Digging+ourselves+out+of+the+mess+Linq-2-SQL+created Modified to work in .NET 3.5