Comment on page
Data Types

Introduction
This page describes the expected data types of the Db.SQL query results for the database object properties, fields and arithmetic operations.
Field and Property Data Types
Your object properties and fields may have the following data types (DbTypeCode):
Binary
Boolean
Byte
DateTime 
Decimal
Double
Int16
Int32
Int64
object
enum
SByte
Single
String
UInt16
UInt32
UInt64
The data types Boolean, Byte, DateTime, Double, Int16, Int32, Int64, SByte, Single, String, UInt16, UInt32, UInt64 correspond to the .NET data types with the same names.
String
The stringdata type can store data up to 1 MB of encoded string data. Thus, all strings with a length of less than 270600 will fit into the string data type. Strings longer than 270600 might fit depending on string content.
Decimal
The data type Decimal is stored as a 64-bit integer and has a precision of six decimals and a range between 4398046511104.999999 and -4398046511103.999999. Trying to set the Decimal data type to a more precise value or to a value outside of the range throws ScErrCLRDecToX6DecRangeError (SCERR4246). In those cases, Double can be used if data loss is acceptable.
Object
The data type object represents a reference to a database object, i.e. an instance of a class, directly or by inheritance having the Database attribute set.
Binary
The data type Binary is for representing binary data up to 1 MB.
Numerical Types
All signed integers, Int64, Int32, Int16 and SByte are represented as Int64 internally in Starcounter SQL. The unsigned integers, UInt64, UInt32, UInt16 and Byte are represented as UInt64. The approximate numerical types Single and Double are represented as Double. 
DateTime
DateTime is represented as an Int64 of the number of .Net ticks from DateTime.MinValue.Ticks.
Enum
enum is supported as a data type. It's stored as a number in the database. Queries on enum will return a number which can be cast to an enum.
using System;
using System.Linq;
using Starcounter;
​
public enum House { Targaryen, Tyrell, Baratheon, Greyjoy };
​
[Database]
public class Person
{
    public House House { get; set; }
}
​
class Program
{
    static void Main()
    {
        Db.Transact(() =>
        {
            var person = new Person() { House = House.Tyrell };
            var house = Db.SQL("SELECT p.House FROM Person p").First();
            Console.Write(house); // => 1
            Console.Write((House)house); // => Tyrell
            Console.Write(Db.FromId<Person>(person.GetObjectID()).House); // => Tyrell
        });
    }
}
Nullable Types
If you want to store null values for data types that essentially are value types, you can instead use the corresponding nullable data types:
Nullable<Boolean>
Nullable<Byte>
Nullable<DateTime>
Nullable<Decimal>
Nullable<Double>
Nullable<Int16>
Nullable<Int32>
Nullable<Int64>
Nullable<SByte>
Nullable<Single>
Nullable<UInt16>
Nullable<UInt32>
Nullable<UInt64>
Arithmetic Operations
The data type of the result of an arithmetic operation is one of the following:
1.Double (representing approximate numeric values) [highest precedence]
2.Decimal (representing exact numeric values)
3.Int64 (representing signed integers)
4.UInt64 (representing unsigned integers - the natural numbers) [lowest precedence]
In general, the data type of the result of an arithmetic operation is the data type with the highest precedence of the data types of the operands.
However, in the following special cases you need a data type with higher precedence to appropriately represent the result:
A subtraction between UInt64's (unsigned integers) has a result of data type Int64 (signed integer).
A division between any combination of UInt64's and Int64's (unsigned and signed integers) has a result of data type Decimal
Collections
It is possible to have collections in the database class if the collection has an explicitly declared body. For example, the following properties are allowed:
public List<string> Branches => new List<string>(){ "develop", "master" };
​
public IEnumerable<Person> Friends => Db.SQL<Person>("SELECT p FROM Person p");
These properties and fields are not allowed:
public string[] Names { get; set; }
public List<Person> People { get; }
public IEnumerable Animals;
The properties with explicitly declared bodies cannot be queried for with SQL, but they can be accessed from the application code after they have been retrieved from the database. If a Person class has the property Friends with a declared body, then Friends can be accessed like so:
var person = Db.SQL<Person>("SELECT p FROM Person p").FirstOrDefault();
IEnumerable<Person> friends = person.Friends;
Querying with SQL
Relations
Last modified 5yr ago