/// <summary>Connects to the specified database and tablename.</summary>
/// <param name="database">Database to connect to.</param>
/// <param name="flags">Flags used to connect to the table.</param>
/// <param name="layout">The table layout.</param>
/// <returns>Returns a new <see cref="PgSqlTable" /> instance.</returns>
public static PgSqlTable Connect(PgSqlDatabase database, TableFlags flags, RowLayout layout)
{
var table = new PgSqlTable();
table.Connect((IDatabase)database, flags, layout);
return(table);
}
/// <inheritdoc />
public ITable GetTable(RowLayout layout, TableFlags flags = default)
{
if (layout == null)
{
throw new ArgumentNullException(nameof(layout));
}
if ((flags & TableFlags.CreateNew) != 0)
{
if (HasTable(layout.Name))
{
DeleteTable(layout.Name);
}
return(CreateTable(layout, flags));
}
if ((flags & TableFlags.AllowCreate) != 0)
{
if (!HasTable(layout.Name))
{
return(CreateTable(layout, flags));
}
}
var table = GetTable(layout.Name);
table.UseLayout(layout);
return(table);
}
/// <inheritdoc />
public void Connect(IDatabase database, TableFlags flags, RowLayout layout)
{
lock (BaseTable)
{
BaseTable.Connect(database, flags, layout);
}
}
/// <summary>Connects to the specified database and tablename.</summary>
/// <param name="database">Database to connect to.</param>
/// <param name="flags">Flags used to connect to the table.</param>
/// <param name="tableName">The table to connect to.</param>
/// <returns>Returns a new <see cref="SQLiteTable" /> instance.</returns>
public static SQLiteTable Connect(SQLiteDatabase database, TableFlags flags, string tableName)
{
var table = new SQLiteTable();
table.Initialize(database, flags, tableName);
return(table);
}
void ExpandLengthPrefix(Context ctx)
{
if (!HasLengthPrefix)
{
return;
}
ExpandInitializer(ctx.FALSE);
ExpandPattern(ctx, 0, true);
// add length to beginning of initializer
var countWithoutLength = ElementCountWithoutLength;
var newInitializer = new ZilObject[countWithoutLength + 1];
newInitializer[0] = new ZilFix(countWithoutLength);
Array.Copy(initializer, 0, newInitializer, 1, countWithoutLength);
initializer = newInitializer;
// set width of the length element in pattern
if ((flags & TableFlags.ByteLength) != 0)
{
pattern[0] = ctx.GetStdAtom(StdAtom.BYTE);
}
else
{
pattern[0] = ctx.GetStdAtom(StdAtom.WORD);
}
// clear length prefix flags
flags &= ~(TableFlags.ByteLength | TableFlags.WordLength);
}
public static bool Test(ITable table, TableFlags tableFlags)
{
if (tableFlags.HasFlag(TableFlags.Private) == true && table.AccessInfo.IsPrivate == false)
{
return(false);
}
if (tableFlags.HasFlag(TableFlags.Public) == true && table.AccessInfo.IsPublic == false)
{
return(false);
}
if (tableFlags.HasFlag(TableFlags.Locked) == true && table.LockInfo.IsLocked == false)
{
return(false);
}
if (tableFlags.HasFlag(TableFlags.NotLocked) == true && table.LockInfo.IsLocked == true)
{
return(false);
}
if (tableFlags.HasFlag(TableFlags.IsBeingEdited) == true && table.TableState != TableState.IsBeingEdited)
{
return(false);
}
if (tableFlags.HasFlag(TableFlags.NotBeingEdited) == true && table.TableState == TableState.IsBeingEdited)
{
return(false);
}
return(true);
}
protected virtual void TableCell(Buffer ob, Buffer text, TableFlags flags)
{
if (base_callbacks.table_cell != null)
{
base_callbacks.table_cell(ob.NativeHandle, text.NativeHandle, (int)flags, opaque);
}
}
/// <inheritdoc />
public ITable CreateTable(RowLayout layout, TableFlags flags = TableFlags.None)
{
var result = database.CreateTable(layout, flags);
tables[result.Name] = result;
return(result);
}
/// <summary>Connects to the specified database and tablename.</summary>
/// <param name="database">Database to connect to.</param>
/// <param name="flags">Flags used to connect to the table.</param>
/// <param name="tableName">The table to connect to.</param>
/// <returns>Returns a new <see cref="MsSqlTable" /> instance.</returns>
public static MsSqlTable Connect(MsSqlDatabase database, TableFlags flags, string tableName)
{
var table = new MsSqlTable();
table.Initialize(database, flags, tableName);
return(table);
}
public OriginalTable(int repetitions, [CanBeNull] ZilObject[] initializer, TableFlags flags,
[CanBeNull] ZilObject[] pattern)
{
this.repetitions = repetitions;
this.initializer = initializer?.Length > 0 ? initializer : null;
this.flags = flags;
this.pattern = pattern;
}
/// <summary>
/// Parse the RopGetRulesTableRequest structure.
/// </summary>
/// <param name="s">An stream containing RopGetRulesTableRequest structure.</param>
public override void Parse(System.IO.Stream s)
{
base.Parse(s);
this.RopId = (RopIdType)ReadByte();
this.LogonId = ReadByte();
this.InputHandleIndex = ReadByte();
this.OutputHandleIndex = ReadByte();
this.TableFlags = (TableFlags)ReadByte();
}
protected TableConfig(IConfig config, TableFlags flags, string identifier, string tableName, Type tableType)
: this()
{
this.Config = config;
this.Flags = flags;
this.Identifier = identifier;
this.TableName = tableName;
this.TableType = tableType;
}
/// <summary>Create reader for stream with SM-BIOS</summary>
/// <exception cref="T:System.IO.IOException">An I/O error occurred while opening the bios.</exception>
public SmBiosReader(MemoryStream input, int version, TableFlags flags = TableFlags.All) : base(input)
{
Data = input.GetBuffer();
if (Version == 0)
{
Version = Const.SMBIOS_3_0;
}
Version = version;
Flags = flags;
}
/// <summary>Initializes the interface class. This is the first method to call after create.</summary>
/// <param name="database">Database the table belongs to.</param>
/// <param name="flags">Flags used to connect to the table.</param>
/// <param name="tableName">Table name to load.</param>
public void Initialize(IDatabase database, TableFlags flags, string tableName)
{
Storage = database.Storage as SqlStorage;
if (Storage == null)
{
throw new InvalidOperationException("Database has to be a SqlDatabase!");
}
FQTN = Storage.FQTN(database.Name, tableName);
var schema = QueryLayout(database.Name, tableName);
base.Connect(database, flags, schema);
}
public void ManyToManyInverse(TableFlags flags)
{
var query = this.Database.QueryFactory.Build();
var parentTable = this.Database.Config.Table <Test002>();
var mappingTable = this.Database.Config.Table <Test002, Test004>();
var childTable = this.Database.Config.Table <Test004>();
var relation = parentTable.Relation(item => item.Test004, Defaults.Relation.Flags | RelationFlags.ManyToMany);
query.Source.AddTable(parentTable.With <ITableConfig>(table =>
{
switch (flags)
{
case TableFlags.Extern:
return(table.Extern());
default:
throw new NotImplementedException();
}
}));
query.Source.AddTable(childTable);
query.RelationManager.AddRelation(relation);
var expressions = query.RelationManager.CalculatedRelations.ToArray();
Assert.AreEqual(2, expressions.Length);
switch (flags)
{
case TableFlags.Extern:
Assert.IsFalse(expressions[0].IsExternal);
Assert.IsTrue(expressions[1].IsExternal);
break;
default:
throw new NotImplementedException();
}
{
var map = expressions[0].Expression.GetColumnMap();
Assert.AreEqual(2, map.Count);
Assert.AreEqual(1, map[mappingTable].Count);
Assert.AreEqual(1, map[childTable].Count);
Assert.AreEqual("Test002_Test004_Test004_Id", map[mappingTable][0].Identifier);
Assert.AreEqual("Test004_Id", map[childTable][0].Identifier);
}
{
var map = expressions[1].Expression.GetColumnMap();
Assert.AreEqual(2, map.Count);
Assert.AreEqual(1, map[parentTable].Count);
Assert.AreEqual(1, map[mappingTable].Count);
Assert.AreEqual("Test002_Id", map[parentTable][0].Identifier);
Assert.AreEqual("Test002_Test004_Test002_Id", map[mappingTable][0].Identifier);
}
}
/// <inheritdoc />
public override void Connect(IDatabase database, TableFlags flags, RowLayout layout)
{
Storage = database.Storage as SqlStorage;
if (Storage == null)
{
throw new InvalidOperationException("Database has to be a SqlDatabase!");
}
FQTN = Storage.FQTN(database.Name, layout.Name);
var schema = QueryLayout(database.Name, layout.Name);
Storage.CheckLayout(layout, schema);
base.Connect(database, flags, schema);
}
public void Load()
{
MetadataReader rdr = new MetadataReader(str);
str.Position = 0;
res = rdr.ReadUInt32();
maVer = rdr.ReadByte();
miVer = rdr.ReadByte();
f = (HeapSizeFlags)rdr.ReadByte();
res2 = rdr.ReadByte();
v = (TableFlags)rdr.ReadUInt64();
s = (TableFlags)rdr.ReadUInt64();
FillLens(rdr);
FillTables(rdr);
}
/// <inheritdoc />
public ITable GetTable(string tableName, TableFlags flags = default)
{
var cached = tables[tableName];
if (cached == null)
{
tables[tableName] = cached = database.GetTable(tableName, flags);
}
if (cached.Flags != flags)
{
throw new ArgumentOutOfRangeException(nameof(tableName), $"Table {cached} was already cached with flags {cached.Flags}!");
}
return(cached);
}
/// <inheritdoc/>
public virtual void Connect(IDatabase database, TableFlags flags, RowLayout layout)
{
if (Database != null)
{
throw new InvalidOperationException("Already initialized!");
}
if (IncreaseSequenceNumber() != 1)
{
throw new InvalidOperationException("Initialization has to take place directly after creating the class!");
}
Flags = flags;
Database = database ?? throw new ArgumentNullException(nameof(database));
Layout = layout ?? throw new ArgumentNullException(nameof(layout));
}
/// <inheritdoc />
public override ITable CreateTable(RowLayout layout, TableFlags flags = default)
{
if (layout == null)
{
throw new ArgumentNullException(nameof(layout));
}
if (tables.ContainsKey(layout.Name))
{
throw new InvalidOperationException($"Table '{layout.Name}' already exists!");
}
var table = MemoryTable.Create(layout);
tables[layout.Name] = table;
return(table);
}
private void FillLens(MetadataReader rdr)
{
len = new uint[0x2d];
mt = new MetadataTable[0x2d];
for (int i = 0; i < 0x2d; i++)
{
TableFlags mask = (TableFlags)((long)1 << i);
if ((v & mask) == mask)
{
len[i] = rdr.ReadUInt32();
mt[i] = new MetadataTable(this, (TableType)i);
}
else
{
mt[i] = null;
}
}
}
/*! \brief Sets up a translation table in a buffer for the given sprite.
* \param [in] spriteArea The sprite area that contains the sprite.
* \param [in] spriteName Name of the sprite to generate the table for.
* \param [in] destMode Destination mode, or -1 for current mode.
* \param [in] destPalette Destination palette, or -1 for current palette,
* or 0 for default palette for the mode.
* \param [in] buffer Pointer to buffer to contain table, or 0 to return size
* of buffer required.
* \param [in] flags Flags (not all flags are settable).
* \return Size of buffer required if \e buffer on input is 0.
* \note The transfer function is not currently supported, therefor bit 2 of
* the flags is ignored.
* \note This method is specifically for a sprite name, therefor bit 0 of
* the flags is ignored. */
public static int GenerateTableForSprite(IntPtr spriteArea,
string spriteName,
int destMode,
IntPtr destPalette,
IntPtr buffer,
TableFlags flags)
{
int buffer_size;
// We don't currently support the transfer function.
flags &= (~(TableFlags.UseTransferFunction | TableFlags.SpritePointerGiven));
OS.ThrowOnError(NativeMethods.ColourTrans_GenerateTableForSprite(spriteArea,
spriteName,
destMode,
destPalette,
buffer,
flags,
IntPtr.Zero,
IntPtr.Zero,
out buffer_size));
return(buffer_size);
}
/// <summary>
/// This ROP gets the rules table of a folder.
/// </summary>
/// <param name="objHandle">This index refers to the location in the Server object handle table used to find the handle for this operation.</param>
/// <param name="tableFlags">These Flags control the Type of table. The possible values are specified in [MS-OXORULE].</param>
/// <param name="getRulesTableResponse">Structure of RopGetRulesTableResponse.</param>
/// <returns>Table handle.</returns>
public uint RopGetRulesTable(uint objHandle, TableFlags tableFlags, out RopGetRulesTableResponse getRulesTableResponse)
{
this.rawData = null;
this.response = null;
this.responseSOHs = null;
RopGetRulesTableRequest getRulesTableRequest;
getRulesTableRequest.RopId = 0x3F;
getRulesTableRequest.LogonId = 0x00;
getRulesTableRequest.InputHandleIndex = 0x00;
getRulesTableRequest.OutputHandleIndex = 0x01;
getRulesTableRequest.TableFlags = (byte)tableFlags;
this.responseSOHs = this.DoRPCCall(getRulesTableRequest, objHandle, ref this.response, ref this.rawData);
getRulesTableResponse = (RopGetRulesTableResponse)this.response;
uint tableHandle = this.responseSOHs[0][getRulesTableResponse.OutputHandleIndex];
// Verify the response of RopGetRulesTable
this.VerifyRopGetRulesTable(getRulesTableResponse, getRulesTableRequest);
return tableHandle;
}
/// <inheritdoc /> public override ITable GetTable(string tableName, TableFlags flags = default) => PgSqlTable.Connect(this, flags, tableName);
protected virtual void TableCell(Buffer ob, Buffer text, TableFlags flags)
{
if (base_callbacks.table_cell != null) {
base_callbacks.table_cell(ob.NativeHandle, text.NativeHandle, (int)flags, opaque);
}
}
/// <inheritdoc /> public abstract void Connect(IDatabase database, TableFlags flags, RowLayout layout);
/// <inheritdoc />
public override ITable CreateTable(RowLayout layout, TableFlags flags)
{
if (layout == null)
{
throw new ArgumentNullException(nameof(layout));
}
if (layout.Name.HasInvalidChars(ASCII.Strings.SafeName))
{
throw new ArgumentException($"Table name {layout.Name} contains invalid chars!");
}
var utf8Charset = ((MySqlStorage)Storage).CharacterSet;
LogCreateTable(layout);
var queryText = new StringBuilder();
queryText.Append($"CREATE TABLE {SqlStorage.FQTN(Name, layout.Name)} (");
for (var i = 0; i < layout.FieldCount; i++)
{
var fieldProperties = layout[i];
if (i > 0)
{
queryText.Append(',');
}
queryText.Append(SqlStorage.EscapeFieldName(fieldProperties));
queryText.Append(' ');
switch (fieldProperties.TypeAtDatabase)
{
case DataType.Binary:
if (fieldProperties.MaximumLength <= 0)
{
queryText.Append("LONGBLOB");
}
else if (fieldProperties.MaximumLength <= 255)
{
queryText.Append("TINYBLOB");
}
else if (fieldProperties.MaximumLength <= 65535)
{
queryText.Append("BLOB");
}
else if (fieldProperties.MaximumLength <= 16777215)
{
queryText.Append("MEDIUMBLOB");
}
else
{
queryText.Append("LONGBLOB");
}
break;
case DataType.Bool:
queryText.Append("TINYINT(1)");
break;
case DataType.DateTime:
switch (fieldProperties.DateTimeType)
{
case DateTimeType.Undefined:
case DateTimeType.Native:
queryText.Append("DATETIME");
break;
case DateTimeType.DoubleEpoch:
case DateTimeType.DoubleSeconds:
queryText.Append("DOUBLE");
break;
case DateTimeType.DecimalSeconds:
queryText.Append("DECIMAL(65,30)");
break;
case DateTimeType.BigIntHumanReadable:
case DateTimeType.BigIntTicks:
queryText.Append("BIGINT");
break;
default: throw new NotImplementedException();
}
break;
case DataType.TimeSpan:
switch (fieldProperties.DateTimeType)
{
case DateTimeType.Undefined:
case DateTimeType.Native:
queryText.Append("TIME");
break;
case DateTimeType.DoubleEpoch:
case DateTimeType.DoubleSeconds:
queryText.Append("DOUBLE");
break;
case DateTimeType.DecimalSeconds:
queryText.Append("DECIMAL(65,30)");
break;
case DateTimeType.BigIntHumanReadable:
case DateTimeType.BigIntTicks:
queryText.Append("BIGINT");
break;
default: throw new NotImplementedException();
}
break;
case DataType.Int8:
queryText.Append("TINYINT");
break;
case DataType.Int16:
queryText.Append("SMALLINT");
break;
case DataType.Int32:
queryText.Append("INTEGER");
break;
case DataType.Int64:
queryText.Append("BIGINT");
break;
case DataType.Single:
queryText.Append("FLOAT");
break;
case DataType.Double:
queryText.Append("DOUBLE");
break;
case DataType.Enum:
queryText.Append("BIGINT");
break;
case DataType.UInt8:
queryText.Append("TINYINT UNSIGNED");
break;
case DataType.UInt16:
queryText.Append("SMALLINT UNSIGNED");
break;
case DataType.UInt32:
queryText.Append("INTEGER UNSIGNED");
break;
case DataType.UInt64:
queryText.Append("BIGINT UNSIGNED");
break;
case DataType.User:
case DataType.String:
if (fieldProperties.MaximumLength <= 0)
{
queryText.Append("LONGTEXT");
}
else if (fieldProperties.MaximumLength <= 255)
{
queryText.Append($"VARCHAR({fieldProperties.MaximumLength})");
}
else if (fieldProperties.MaximumLength <= 65535)
{
queryText.Append("TEXT");
}
else if (fieldProperties.MaximumLength <= 16777215)
{
queryText.Append("MEDIUMTEXT");
}
else
{
queryText.Append("LONGTEXT");
}
switch (fieldProperties.StringEncoding)
{
case StringEncoding.Undefined:
case StringEncoding.ASCII:
queryText.Append(" CHARACTER SET latin1 COLLATE latin1_general_ci");
break;
case StringEncoding.UTF8:
queryText.Append($" CHARACTER SET utf8mb4 COLLATE {utf8Charset}_general_ci");
break;
case StringEncoding.UTF16:
queryText.Append(" CHARACTER SET ucs2 COLLATE ucs2_general_ci");
break;
case StringEncoding.UTF32:
queryText.Append(" CHARACTER SET utf32 COLLATE utf32_general_ci");
break;
default: throw new NotSupportedException($"MYSQL Server does not support {fieldProperties.StringEncoding}!");
}
break;
case DataType.Decimal:
if (fieldProperties.MaximumLength > 0)
{
var precision = (int)fieldProperties.MaximumLength;
var scale = (int)((fieldProperties.MaximumLength - precision) * 100);
if (scale >= precision)
{
throw new ArgumentOutOfRangeException(
$"Field {fieldProperties.Name} has an invalid MaximumLength of {precision},{scale}. Correct values range from s,p = 1,0 to 65,30(default value) with 0 < s < p!");
}
queryText.Append($"DECIMAL({precision},{scale})");
}
else
{
queryText.Append("DECIMAL(65,30)");
}
break;
default: throw new NotImplementedException($"Unknown DataType {fieldProperties.DataType}!");
}
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
queryText.Append(" AUTO_INCREMENT");
}
if ((fieldProperties.Flags & FieldFlags.Unique) != 0)
{
queryText.Append(" UNIQUE");
switch (fieldProperties.TypeAtDatabase)
{
case DataType.Bool:
case DataType.Char:
case DataType.DateTime:
case DataType.Decimal:
case DataType.Double:
case DataType.Enum:
case DataType.Int8:
case DataType.Int16:
case DataType.Int32:
case DataType.Int64:
case DataType.UInt8:
case DataType.UInt16:
case DataType.UInt32:
case DataType.UInt64:
case DataType.Single:
case DataType.TimeSpan:
break;
case DataType.String:
if (fieldProperties.MaximumLength <= 0)
{
throw new NotSupportedException(
$"Unique string fields without length are not supported! Please define Field.MaxLength at tableName {layout.Name} field {fieldProperties.Name}");
}
break;
default: throw new NotSupportedException($"Uniqueness for tableName {layout.Name} field {fieldProperties.Name} is not supported!");
}
}
if (fieldProperties.Description != null)
{
if (fieldProperties.Description.HasInvalidChars(ASCII.Strings.Printable))
{
throw new ArgumentException("Description of field '{0}' contains invalid chars!", fieldProperties.Name);
}
queryText.Append(" COMMENT '" + fieldProperties.Description.Substring(0, 60) + "'");
}
}
if (layout.Identifier.Any())
{
queryText.Append(",PRIMARY KEY(");
var count = 0;
foreach (var field in layout.Identifier)
{
if (count++ > 0)
{
queryText.Append(',');
}
queryText.Append(SqlStorage.EscapeFieldName(field));
}
queryText.Append(')');
}
queryText.Append(')');
if ((flags & TableFlags.InMemory) != 0)
{
queryText.Append(" ENGINE = MEMORY");
}
SqlStorage.Execute(database: Name, table: layout.Name, cmd: queryText.ToString());
try
{
for (var i = 0; i < layout.FieldCount; i++)
{
var field = layout[i];
if ((field.Flags & FieldFlags.ID) != 0)
{
continue;
}
if ((field.Flags & FieldFlags.Index) != 0)
{
string command;
switch (field.DataType)
{
case DataType.Binary:
case DataType.String:
case DataType.User:
var size = (int)field.MaximumLength;
if (size < 1)
{
size = 32;
}
command =
$"CREATE INDEX `idx_{layout.Name}_{field.Name}` ON {SqlStorage.FQTN(Name, layout.Name)} ({SqlStorage.EscapeFieldName(field)} ({size}))";
break;
case DataType.Bool:
case DataType.Char:
case DataType.DateTime:
case DataType.Decimal:
case DataType.Double:
case DataType.Enum:
case DataType.Int16:
case DataType.Int32:
case DataType.Int64:
case DataType.Int8:
case DataType.Single:
case DataType.TimeSpan:
case DataType.UInt16:
case DataType.UInt32:
case DataType.UInt64:
case DataType.UInt8:
command =
$"CREATE INDEX `idx_{layout.Name}_{field.Name}` ON {SqlStorage.FQTN(Name, layout.Name)} ({SqlStorage.EscapeFieldName(field)})";
break;
default: throw new NotSupportedException($"INDEX for datatype of field {field} is not supported!");
}
SqlStorage.Execute(database: Name, table: layout.Name, cmd: command);
}
}
}
catch
{
DeleteTable(layout.Name);
throw;
}
return(GetTable(layout));
}
/// <inheritdoc /> public override ITable GetTable(string tableName, TableFlags flags) => MySqlTable.Connect(this, flags, tableName);
/// <summary>
/// Creates a new table with the specified layout.
/// </summary>
/// <typeparam name="TKey">Key identifier type.</typeparam>
/// <typeparam name="TStruct">Row structure type.</typeparam>
/// <param name="database">The database to create the table at.</param>
/// <param name="tableName">The name of the table.</param>
/// <param name="flags">Flags for table creation.</param>
/// <param name="excludedFields">Fields at <typeparamref name="TStruct"/> to be excluded.</param>
/// <returns>Returns an <see cref="ITable{TKey, TStruct}"/> instance for the specified table.</returns>
public static ITable <TKey, TStruct> CreateTable <TKey, TStruct>(this IDatabase database, string tableName = null, TableFlags flags = default,
params string[] excludedFields)
where TKey : IComparable <TKey>
where TStruct : struct
{
if (database == null)
{
throw new ArgumentNullException(nameof(database));
}
var layout = RowLayout.CreateTyped(typeof(TStruct), tableName, database.Storage, excludedFields);
var table = database.CreateTable(layout, flags);
return(new Table <TKey, TStruct>(table));
}
/// <inheritdoc />
public override ITable CreateTable(RowLayout layout, TableFlags flags)
{
if (layout == null)
{
throw new ArgumentNullException(nameof(layout));
}
LogCreateTable(layout);
if ((flags & TableFlags.InMemory) != 0)
{
throw new NotSupportedException($"Table '{layout.Name}' does not support TableFlags.{TableFlags.InMemory}");
}
if (layout.Name.HasInvalidChars(ASCII.Strings.SafeName))
{
throw new ArgumentException($"Table name {layout.Name} contains invalid chars!");
}
var queryText = new StringBuilder();
queryText.Append($"CREATE TABLE {SqlStorage.FQTN(Name, layout.Name)} (");
for (var i = 0; i < layout.FieldCount; i++)
{
var fieldProperties = layout[i];
if (i > 0)
{
queryText.Append(",");
}
queryText.Append(fieldProperties.NameAtDatabase + " ");
switch (fieldProperties.DataType)
{
case DataType.Binary:
queryText.Append("VARBINARY(MAX)");
break;
case DataType.Bool:
queryText.Append("BIT");
break;
case DataType.DateTime:
switch (fieldProperties.DateTimeType)
{
case DateTimeType.Undefined:
case DateTimeType.Native:
queryText.Append("DATETIME");
break;
case DateTimeType.DoubleSeconds:
case DateTimeType.DoubleEpoch:
queryText.Append("FLOAT(53)");
break;
case DateTimeType.DecimalSeconds:
queryText.Append("NUMERIC(28,8)");
break;
case DateTimeType.BigIntHumanReadable:
case DateTimeType.BigIntTicks:
queryText.Append("BIGINT");
break;
default: throw new NotImplementedException();
}
break;
case DataType.TimeSpan:
switch (fieldProperties.DateTimeType)
{
case DateTimeType.Undefined:
case DateTimeType.Native:
queryText.Append("TIMESPAN");
break;
case DateTimeType.DoubleEpoch:
case DateTimeType.DoubleSeconds:
queryText.Append("FLOAT(53)");
break;
case DateTimeType.DecimalSeconds:
queryText.Append("NUMERIC(28,8)");
break;
case DateTimeType.BigIntHumanReadable:
case DateTimeType.BigIntTicks:
queryText.Append("BIGINT");
break;
default: throw new NotImplementedException();
}
break;
case DataType.Int8:
queryText.Append("SMALLINT");
break;
case DataType.Int16:
queryText.Append("SMALLINT");
break;
case DataType.Int32:
queryText.Append("INTEGER");
break;
case DataType.Int64:
queryText.Append("BIGINT");
break;
case DataType.Single:
queryText.Append("REAL");
break;
case DataType.Double:
queryText.Append("FLOAT(53)");
break;
case DataType.Enum:
queryText.Append("BIGINT");
break;
case DataType.User:
case DataType.String:
switch (fieldProperties.StringEncoding)
{
case StringEncoding.ASCII:
if ((fieldProperties.MaximumLength > 0) && (fieldProperties.MaximumLength <= 255))
{
queryText.AppendFormat("VARCHAR({0})", fieldProperties.MaximumLength);
}
else
{
queryText.Append("VARCHAR(MAX)");
}
break;
case StringEncoding.UTF16:
case StringEncoding.UTF8:
if ((fieldProperties.MaximumLength > 0) && (fieldProperties.MaximumLength <= 255))
{
queryText.AppendFormat("NVARCHAR({0})", fieldProperties.MaximumLength);
}
else
{
queryText.Append("NVARCHAR(MAX)");
}
break;
default: throw new NotSupportedException($"MSSQL Server does not support {fieldProperties.StringEncoding}!");
}
break;
case DataType.Decimal:
if (fieldProperties.MaximumLength > 0)
{
var l_PreDecimal = (int)fieldProperties.MaximumLength;
var l_Temp = (fieldProperties.MaximumLength - l_PreDecimal) * 100;
var l_Decimal = (int)l_Temp;
if ((l_Decimal >= l_PreDecimal) || (l_Decimal != l_Temp))
{
throw new ArgumentOutOfRangeException(
$"Field {fieldProperties.Name} has an invalid MaximumLength of {l_PreDecimal},{l_Decimal}. Correct values range from s,p = 1,0 to 28,27 with 0 < s < p!");
}
queryText.AppendFormat("NUMERIC({0},{1})", l_PreDecimal, l_Decimal);
}
else
{
queryText.Append("NUMERIC(28,8)");
}
break;
default: throw new NotImplementedException($"Unknown DataType {fieldProperties.DataType}!");
}
if ((fieldProperties.Flags & FieldFlags.ID) != 0)
{
queryText.Append(" PRIMARY KEY");
}
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
queryText.Append(" IDENTITY");
}
if ((fieldProperties.Flags & FieldFlags.Unique) != 0)
{
queryText.Append(" UNIQUE");
switch (fieldProperties.TypeAtDatabase)
{
case DataType.Bool:
case DataType.Char:
case DataType.DateTime:
case DataType.Decimal:
case DataType.Double:
case DataType.Enum:
case DataType.Int8:
case DataType.Int16:
case DataType.Int32:
case DataType.Int64:
case DataType.UInt8:
case DataType.UInt16:
case DataType.UInt32:
case DataType.UInt64:
case DataType.Single:
case DataType.TimeSpan:
break;
case DataType.String:
if (fieldProperties.MaximumLength <= 0)
{
throw new NotSupportedException(
$"Unique string fields without length are not supported! Please define Field.MaxLength at table {layout.Name} field {fieldProperties.Name}");
}
break;
default: throw new NotSupportedException($"Uniqueness for table {layout.Name} field {fieldProperties.Name} is not supported!");
}
}
if (fieldProperties.Description != null)
{
if (fieldProperties.Description.HasInvalidChars(ASCII.Strings.Printable))
{
throw new ArgumentException("Description of field '{0}' contains invalid chars!", fieldProperties.Name);
}
queryText.Append(" COMMENT '" + fieldProperties.Description.Substring(0, 60) + "'");
}
}
queryText.Append(")");
SqlStorage.Execute(database: Name, table: layout.Name, cmd: queryText.ToString());
for (var i = 0; i < layout.FieldCount; i++)
{
var fieldProperties = layout[i];
if ((fieldProperties.Flags & FieldFlags.ID) != 0)
{
continue;
}
if ((fieldProperties.Flags & FieldFlags.Index) != 0)
{
var command =
$"CREATE INDEX idx_{SqlStorage.EscapeString(fieldProperties.NameAtDatabase)} ON {SqlStorage.FQTN(Name, layout.Name)} ({SqlStorage.EscapeFieldName(fieldProperties)})";
SqlStorage.Execute(database: Name, table: layout.Name, cmd: command);
}
}
return(GetTable(layout));
}
/// <inheritdoc/> public void Connect(IDatabase database, TableFlags flags, RowLayout layout) => Table.Connect(database, flags, layout);
/// <summary>Adds a new tableName with the specified name.</summary>
/// <param name="layout">Layout of the tableName.</param>
/// <param name="flags">The flags for tableName creation.</param>
/// <returns>Returns an <see cref="ITable" /> instance for the specified tableName.</returns>
public override ITable CreateTable(RowLayout layout, TableFlags flags = default)
{
if (layout == null)
{
throw new ArgumentNullException(nameof(layout));
}
Trace.TraceInformation($"Creating tableName {layout}");
if (layout.Name.HasInvalidChars(ASCII.Strings.SafeName))
{
throw new ArgumentException($"Table name {layout.Name} contains invalid chars!");
}
var queryText = new StringBuilder();
queryText.Append("CREATE ");
if ((flags & TableFlags.InMemory) != 0)
{
queryText.Append("UNLOGGED ");
}
queryText.Append($"TABLE {SqlStorage.FQTN(Name, layout.Name)} (");
for (var i = 0; i < layout.FieldCount; i++)
{
var fieldProperties = layout[i];
if (i > 0)
{
queryText.Append(',');
}
var fieldName = SqlStorage.EscapeFieldName(fieldProperties);
queryText.Append(fieldName);
queryText.Append(' ');
switch (fieldProperties.TypeAtDatabase)
{
case DataType.Binary:
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
throw new NotSupportedException($"AutoIncrement is not supported on data type {fieldProperties.TypeAtDatabase}");
}
queryText.Append("BYTEA");
break;
case DataType.Bool:
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
throw new NotSupportedException($"AutoIncrement is not supported on data type {fieldProperties.TypeAtDatabase}");
}
queryText.Append("BOOL");
break;
case DataType.DateTime:
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
throw new NotSupportedException($"AutoIncrement is not supported on data type {fieldProperties.TypeAtDatabase}");
}
queryText.Append("TIMESTAMP WITH TIME ZONE");
break;
case DataType.TimeSpan:
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
throw new NotSupportedException($"AutoIncrement is not supported on data type {fieldProperties.TypeAtDatabase}");
}
queryText.Append("FLOAT8");
break;
case DataType.Int8:
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
throw new NotSupportedException($"AutoIncrement is not supported on data type {fieldProperties.TypeAtDatabase}");
}
queryText.Append("SMALLINT");
break;
case DataType.Int16:
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
queryText.Append("SMALLSERIAL");
}
else
{
queryText.Append("SMALLINT");
}
break;
case DataType.Int32:
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
queryText.Append("SERIAL");
}
else
{
queryText.Append("INTEGER");
}
break;
case DataType.Int64:
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
queryText.Append("BIGSERIAL");
}
else
{
queryText.Append("BIGINT");
}
break;
case DataType.Single:
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
throw new NotSupportedException($"AutoIncrement is not supported on data type {fieldProperties.TypeAtDatabase}");
}
queryText.Append("FLOAT4");
break;
case DataType.Double:
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
throw new NotSupportedException($"AutoIncrement is not supported on data type {fieldProperties.TypeAtDatabase}");
}
queryText.Append("FLOAT8");
break;
case DataType.Enum:
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
throw new NotSupportedException($"AutoIncrement is not supported on data type {fieldProperties.TypeAtDatabase}");
}
queryText.Append("BIGINT");
break;
case DataType.UInt8:
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
throw new NotSupportedException($"AutoIncrement is not supported on data type {fieldProperties.TypeAtDatabase}");
}
queryText.Append($"SMALLINT CHECK ({fieldName} >= 0 AND {fieldName} <= {byte.MaxValue})");
break;
case DataType.UInt16:
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
throw new NotSupportedException($"AutoIncrement is not supported on data type {fieldProperties.TypeAtDatabase}");
}
queryText.Append($"INT CHECK ({fieldName} >= 0 AND {fieldName} <= {ushort.MaxValue})");
break;
case DataType.UInt32:
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
throw new NotSupportedException($"AutoIncrement is not supported on data type {fieldProperties.TypeAtDatabase}");
}
queryText.Append($"BIGINT CHECK ({fieldName} >= 0 AND {fieldName} <= {uint.MaxValue})");
break;
case DataType.UInt64:
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
throw new NotSupportedException($"AutoIncrement is not supported on data type {fieldProperties.TypeAtDatabase}");
}
queryText.Append($"NUMERIC(20,0) CHECK ({fieldName} >= 0 AND {fieldName} <= {ulong.MaxValue})");
break;
case DataType.User:
case DataType.String:
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
throw new NotSupportedException($"AutoIncrement is not supported on data type {fieldProperties.TypeAtDatabase}");
}
if (fieldProperties.MaximumLength <= 0)
{
queryText.Append("TEXT");
}
else
{
queryText.Append($"VARCHAR({fieldProperties.MaximumLength})");
}
break;
case DataType.Decimal:
if ((fieldProperties.Flags & FieldFlags.AutoIncrement) != 0)
{
throw new NotSupportedException($"AutoIncrement is not supported on data type {fieldProperties.TypeAtDatabase}");
}
if (fieldProperties.MaximumLength > 0)
{
var precision = (int)fieldProperties.MaximumLength;
var scale = (int)((fieldProperties.MaximumLength - precision) * 100);
if (scale >= precision)
{
throw new ArgumentOutOfRangeException(
$"Field {fieldProperties.Name} has an invalid MaximumLength of {precision},{scale}. Correct values range from s,p = 1,0 to 65,30(default value) with 0 < s < p!");
}
queryText.Append($"DECIMAL({precision},{scale})");
}
else
{
queryText.Append("DECIMAL(65,30)");
}
break;
default: throw new NotImplementedException($"Unknown DataType {fieldProperties.DataType}!");
}
if ((fieldProperties.Flags & FieldFlags.ID) != 0)
{
queryText.Append(" PRIMARY KEY");
}
if ((fieldProperties.Flags & FieldFlags.Unique) != 0)
{
queryText.Append(" UNIQUE");
switch (fieldProperties.TypeAtDatabase)
{
case DataType.Bool:
case DataType.Char:
case DataType.DateTime:
case DataType.Decimal:
case DataType.Double:
case DataType.Enum:
case DataType.Int8:
case DataType.Int16:
case DataType.Int32:
case DataType.Int64:
case DataType.UInt8:
case DataType.UInt16:
case DataType.UInt32:
case DataType.UInt64:
case DataType.Single:
case DataType.TimeSpan:
break;
case DataType.String:
if (fieldProperties.MaximumLength <= 0)
{
throw new NotSupportedException(
$"Unique string fields without length are not supported! Please define Field.MaxLength at tableName {layout.Name} field {fieldProperties.Name}");
}
break;
default: throw new NotSupportedException($"Uniqueness for tableName {layout.Name} field {fieldProperties.Name} is not supported!");
}
}
if (fieldProperties.Description != null)
{
if (fieldProperties.Description.HasInvalidChars(ASCII.Strings.Printable))
{
throw new ArgumentException("Description of field '{0}' contains invalid chars!", fieldProperties.Name);
}
queryText.Append(" COMMENT '" + fieldProperties.Description.Substring(0, 60) + "'");
}
}
queryText.Append(')');
SqlStorage.Execute(database: Name, table: layout.Name, cmd: queryText.ToString());
for (var i = 0; i < layout.FieldCount; i++)
{
var fieldProperties = layout[i];
if ((fieldProperties.Flags & FieldFlags.ID) != 0)
{
continue;
}
if ((fieldProperties.Flags & FieldFlags.Index) != 0)
{
var name = PgSqlStorage.GetObjectName($"idx_{layout.Name}_{fieldProperties.Name}");
var cmd = $"CREATE INDEX {name} ON {SqlStorage.FQTN(Name, layout.Name)} ({SqlStorage.EscapeFieldName(fieldProperties)})";
SqlStorage.Execute(database: Name, table: layout.Name, cmd: cmd);
}
}
return(GetTable(layout));
}
/// <summary>
/// Get hierarchy table
/// </summary>
/// <param name="serverID">server id.</param>
/// <param name="handle">Table handle</param>
/// <param name="flag">A TableFlags value</param>
/// <param name="soh">Server object handle.</param>
/// <returns>The response of RopGetHierarchyTable operation.</returns>
private RopGetHierarchyTableResponse GetHierarchyTable(
int serverID,
uint handle,
TableFlags flag,
out List<uint> soh)
{
RopGetHierarchyTableRequest getHierarchyTableRequest;
// Construct ROP request.
getHierarchyTableRequest.RopId = 0x04;
getHierarchyTableRequest.LogonId = 0x00;
getHierarchyTableRequest.InputHandleIndex = 0x00;
getHierarchyTableRequest.OutputHandleIndex = 0x01;
getHierarchyTableRequest.TableFlags = (byte)flag;
// Send the request.
RopGetHierarchyTableResponse rt = (RopGetHierarchyTableResponse)this.Process(
serverID, getHierarchyTableRequest, handle);
soh = this.responseSOHs;
return rt;
}
