/// <summary>
/// Opens the transaction log for writing.
/// </summary>
private void OpenScript()
{
if (TracingHelper.TraceEnabled)
{
TracingHelper.Write();
}
try
{
// opens the log file exclusively for writing
_file = new FileStream(sFileScript, FileMode.Append, FileAccess.Write, FileShare.None);
// todo: use a compressed stream
wScript = new StreamWriter(_file, System.Text.Encoding.UTF8);
#if !POCKETPC
tRunner = new Thread(new ThreadStart(Run));
tRunner.IsBackground = true;
tRunner.Start();
#endif
}
catch (Exception e)
{
LogHelper.Publish("Unexpected error on OpenScript.", e);
TracingHelper.Error(TracingHelper.FILE_IO_ERROR, sFileScript);
}
}
private int[] ProcessColumnList(Tokenizer tokenizer, Table table)
{
ArrayList v = new ArrayList();
tokenizer.GetThis("(");
while (true)
{
v.Add(tokenizer.GetString());
string sToken = tokenizer.GetString();
if (sToken.Equals(")"))
{
break;
}
if (!sToken.Equals(","))
{
throw TracingHelper.Error(TracingHelper.UnexpectedToken, sToken);
}
}
int s = v.Count;
int[] col = new int[s];
for (int i = 0; i < s; i++)
{
col[i] = table.GetColumnNumber((string)v[i]);
}
return(col);
}
public static string InputStreamTostring(BinaryReader reader)
{
StringWriter write = new StringWriter();
int blocksize = 8 * 1024; // todo: is this a good value?
char[] buffer = new char[blocksize];
try
{
while (true)
{
int l = reader.Read(buffer, 0, blocksize);
if (l == -1)
{
break;
}
write.Write(buffer, 0, l);
}
write.Close();
reader.Close();
}
catch (IOException e)
{
throw TracingHelper.Error(TracingHelper.INPUTSTREAM_ERROR, e.Message);
}
return(write.ToString());
}
/// <summary>
/// Close the transaction log file.
/// </summary>
private void CloseScript()
{
if (TracingHelper.TraceEnabled)
{
TracingHelper.Write();
}
try
{
if (wScript != null)
{
Stop();
wScript.Close();
wScript = null;
_file = null;
}
}
catch (Exception e)
{
LogHelper.Publish("Unexpected error on CloseScript.", e);
TracingHelper.Error(TracingHelper.FILE_IO_ERROR, sFileScript);
}
}
/// <summary>
/// GetRight method declaration.
/// This GetRight method takes a string argument of the name of the access right.
/// </summary>
/// <param name="right">A string representation of the right.</param>
/// <returns>A static int representing the string right passed in.</returns>
public static AccessType GetRight(string right)
{
if (right.Equals("ALL"))
{
return(AccessType.All);
}
else if (right.Equals("SELECT"))
{
return(AccessType.Select);
}
else if (right.Equals("UPDATE"))
{
return(AccessType.Update);
}
else if (right.Equals("DELETE"))
{
return(AccessType.Delete);
}
else if (right.Equals("INSERT"))
{
return(AccessType.Insert);
}
throw TracingHelper.Error(TracingHelper.UnexpectedToken, right);
}
/// <summary>
/// Checks a database object for the specified right.
/// </summary>
/// <param name="dbobject">Database object checking.</param>
/// <param name="right">Desired right.</param>
internal void Check(string dbobject, AccessType right)
{
if (_administrator)
{
return;
}
AccessType n;
n = (AccessType)_right[dbobject];
if ((n & right) != 0)
{
return;
}
if (_public != null)
{
n = (AccessType)(_public._right)[dbobject];
if ((n & right) != 0)
{
return;
}
}
throw TracingHelper.Error(TracingHelper.ACCESS_IS_DENIED);
}
/// <summary>
/// Multiply two objects.
/// </summary>
/// <param name="one"></param>
/// <param name="two"></param>
/// <param name="type"></param>
/// <returns></returns>
internal static object Multiply(object one, object two, ColumnType type)
{
if (one == null || two == null)
{
return(null);
}
switch (type)
{
case ColumnType.Null:
return(null);
case ColumnType.Integer:
int ai = (int)one;
int bi = (int)two;
return(ai * bi);
case ColumnType.Float:
case ColumnType.Real:
float floata = (float)one;
float floatb = (float)two;
return(floata * floatb);
case ColumnType.DbDouble:
double ad = (double)one;
double bd = (double)two;
return(ad * bd);
case ColumnType.Numeric:
case ColumnType.DbDecimal:
decimal abd = (decimal)one;
decimal bbd = (decimal)two;
return(abd * bbd);
case ColumnType.TinyInt:
byte ba = (byte)one;
byte bb = (byte)two;
return(ba * bb);
case ColumnType.SmallInt:
short shorta = (short)one;
short shortb = (short)two;
return(shorta * shortb);
case ColumnType.BigInt:
long longa = (long)one;
long longb = (long)two;
return(longa * longb);
default:
throw TracingHelper.Error(TracingHelper.FUNCTION_NOT_SUPPORTED, (int)type);
}
}
private static int GetElapsed(string part, DateTime d1, DateTime d2)
{
TimeSpan elapsed = d1.Subtract(d2);
switch (part)
{
case "year":
return(new DateTime(elapsed.Ticks).Year);
case "month":
return(new DateTime(elapsed.Ticks).Month);
case "day":
return(new DateTime(elapsed.Ticks).Day);
case "hour":
return(new DateTime(elapsed.Ticks).Hour);
case "minute":
return(new DateTime(elapsed.Ticks).Minute);
case "second":
return(new DateTime(elapsed.Ticks).Second);
case "ms":
return(new DateTime(elapsed.Ticks).Millisecond);
default:
throw TracingHelper.Error(TracingHelper.ERROR_IN_FUNCTION);
}
}
private Result ProcessDrop(Tokenizer tokenizer, Channel channel)
{
channel.CheckReadWrite();
channel.CheckAdmin();
string sToken = tokenizer.GetString();
if (sToken.Equals("TABLE"))
{
sToken = tokenizer.GetString();
if (sToken.Equals("IF"))
{
sToken = tokenizer.GetString(); // EXISTS
sToken = tokenizer.GetString(); // <table>
DropTable(sToken, true);
}
else
{
DropTable(sToken, false);
}
channel.Commit();
}
else if (sToken.Equals("USER"))
{
_access.DropUser(tokenizer.GetStringToken());
}
else if (sToken.Equals("INDEX"))
{
sToken = tokenizer.GetString();
if (!tokenizer.WasLongName)
{
throw TracingHelper.Error(TracingHelper.UnexpectedToken, sToken);
}
string table = tokenizer.LongNameFirst;
string index = tokenizer.LongNameLast;
Table t = GetTable(table, channel);
t.CheckDropIndex(index);
Table tn = t.MoveDefinition(index);
tn.MoveData(t);
DropTable(table);
LinkTable(tn);
channel.Commit();
}
else
{
throw TracingHelper.Error(TracingHelper.UnexpectedToken, sToken);
}
return(new Result());
}
public void GetThis(string match)
{
GetToken();
if (!sToken.Equals(match))
{
throw TracingHelper.Error(TracingHelper.UnexpectedToken, sToken);
}
}
private Result ProcessGrantOrRevoke(Tokenizer c, Channel channel, bool grant)
{
channel.CheckReadWrite();
channel.CheckAdmin();
AccessType right = AccessType.None;
string sToken;
do
{
string sRight = c.GetString();
right |= Access.GetRight(sRight);
sToken = c.GetString();
} while (sToken.Equals(","));
if (!sToken.Equals("ON"))
{
throw TracingHelper.Error(TracingHelper.UnexpectedToken, sToken);
}
string table = c.GetString();
if (table.Equals("CLASS"))
{
// object is saved as 'CLASS "java.lang.Math"'
// tables like 'CLASS "xy"' should not be created
table += " \"" + c.GetString() + "\"";
}
else
{
GetTable(table, channel); // to make sure the table exists
}
c.GetThis("TO");
string user = c.GetStringToken();
// string command;
if (grant)
{
_access.Grant(user, table, right);
// command = "GRANT";
}
else
{
_access.Revoke(user, table, right);
// command = "REVOKE";
}
return(new Result());
}
public string GetName()
{
GetToken();
if (!WasName)
{
throw TracingHelper.Error(TracingHelper.UnexpectedToken, sToken);
}
return(sToken);
}
/// <summary>
/// Constructor for a result based on a byte stream.
/// </summary>
/// <param name="b"></param>
internal Result(byte[] b)
{
MemoryStream bin = new MemoryStream(b);
BinaryReader din = new BinaryReader(bin);
try
{
#if !POCKETPC
_mode = (ResultType)Enum.Parse(typeof(ResultType), din.ReadInt32().ToString());
#else
_mode = (ResultType)OpenNETCF.EnumEx.Parse(typeof(ResultType), din.ReadInt32().ToString());
#endif
if (_mode == ResultType.Error)
{
throw TracingHelper.GetError(din.ReadString());
}
else if (_mode == ResultType.UpdateCount)
{
_updateCount = din.ReadInt32();
}
else if (_mode == ResultType.Data)
{
int l = din.ReadInt32();
PrepareData(l);
_columnCount = l;
for (int i = 0; i < l; i++)
{
#if !POCKETPC
Type[i] = (ColumnType)Enum.Parse(typeof(ColumnType), din.ReadInt32().ToString());
#else
Type[i] = (ColumnType)OpenNETCF.EnumEx.Parse(typeof(ColumnType), din.ReadInt32().ToString());
#endif
Label[i] = din.ReadString();
Table[i] = din.ReadString();
Name[i] = din.ReadString();
}
while (din.PeekChar() != -1)
{
Add(Column.ReadData(din, l));
}
}
}
catch (Exception e)
{
LogHelper.Publish("Unexpected error on Result.", e);
TracingHelper.Error(TracingHelper.TRANSFER_CORRUPTED);
}
}
/// <summary>
/// Shutdown method declaration.
/// The shutdown method closes the cache file.
/// It does not flush pending writes.
/// </summary>
public void Shutdown()
{
try
{
_fileStream.Close();
}
catch (Exception e)
{
throw TracingHelper.Error(TracingHelper.FILE_IO_ERROR, "error " + e + " in shutdown " + _name);
}
}
public int GetColumnNumber(string c)
{
int i = SearchColumn(c);
if (i == -1)
{
throw TracingHelper.Error(TracingHelper.COLUMN_NOT_FOUND, c);
}
return(i);
}
/// <summary>
/// Gets the Type code of the string representation of a data type.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
internal static ColumnType GetColumnType(string type)
{
FillTypes();
if (_types.ContainsKey(type))
{
return((ColumnType)_types[type]);
}
else
{
throw TracingHelper.Error(TracingHelper.WRONG_DATA_TYPE, type);
}
}
/// <summary>
/// Restores a previous backup.
/// </summary>
private void RestoreBackup()
{
if (TracingHelper.TraceEnabled)
{
TracingHelper.Write("Not closed last time!");
}
if (!(new FileInfo(sFileBackup)).Exists)
{
// the backup don't exists because it was never made or is empty
// the cache file must be deleted in this case
(new FileInfo(sFileCache)).Delete();
return;
}
try
{
DateTime time = DateTime.Now;
BinaryReader f = new BinaryReader(new FileStream(sFileBackup, FileMode.Open, FileAccess.Read));
BinaryWriter cache = new BinaryWriter(new FileStream(sFileCache, FileMode.OpenOrCreate, FileAccess.Write));
byte[] b = new byte[COPY_BLOCK_SIZE];
while (true)
{
int l = f.Read(b, 0, COPY_BLOCK_SIZE);
if (l == 0)
{
break;
}
cache.Write(b, 0, l);
}
cache.Close();
f.Close();
TimeSpan execution = DateTime.Now.Subtract(time);
if (TracingHelper.TraceEnabled)
{
TracingHelper.Write((Int64)execution.TotalMilliseconds);
}
}
catch (Exception e)
{
LogHelper.Publish("Unexpected error on RestoreBackup.", e);
throw TracingHelper.Error(TracingHelper.FILE_IO_ERROR, sFileBackup);
}
}
public void CheckDropIndex(string index)
{
for (int i = 0; i < iIndexCount; i++)
{
if (index.Equals(GetIndex(i).Name))
{
TracingHelper.Check(i != 0, TracingHelper.DROP_PRIMARY_KEY);
return;
}
}
throw TracingHelper.Error(TracingHelper.INDEX_NOT_FOUND, index);
}
/// <summary>
/// Close the database properties file.
/// </summary>
private void CloseProperties()
{
try
{
if (TracingHelper.TraceEnabled)
{
TracingHelper.Write();
}
}
catch (Exception e)
{
throw TracingHelper.Error(TracingHelper.FILE_IO_ERROR, sFileProperties + " " + e);
}
}
/// <summary>
/// Performs a backup of the current database.
/// </summary>
private void Backup()
{
if (TracingHelper.TraceEnabled)
{
TracingHelper.Write();
}
// if there is no cache file then backup is not necessary
if (!(new FileInfo(sFileCache)).Exists)
{
return;
}
try
{
DateTime time = DateTime.Now;
// create a '.new' file; rename later
BinaryWriter f = new BinaryWriter(new FileStream(sFileBackup + ".new", FileMode.OpenOrCreate, FileAccess.Write));
byte[] b = new byte[COPY_BLOCK_SIZE];
BinaryReader fin = new BinaryReader(new FileStream(sFileCache, FileMode.Open, FileAccess.Read));
while (true)
{
int l = fin.Read(b, 0, COPY_BLOCK_SIZE);
if (l == 0)
{
break;
}
f.Write(b, 0, l);
}
f.Close();
fin.Close();
TimeSpan execution = DateTime.Now.Subtract(time);
if (TracingHelper.TraceEnabled)
{
TracingHelper.Write((Int64)execution.TotalMilliseconds);
}
}
catch (Exception e)
{
LogHelper.Publish("Unexpected error on Backup.", e);
throw TracingHelper.Error(TracingHelper.FILE_IO_ERROR, sFileBackup);
}
}
/// <summary>
/// This private method is used to access the User objects in the collection
/// and perform operations on them.
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
private User Get(string name)
{
for (int i = 0; i < uUser.Count; i++)
{
User u = (User)uUser[i];
if (u != null && u.Name.Equals(name))
{
return(u);
}
}
throw TracingHelper.Error(TracingHelper.USER_NOT_FOUND, name);
}
/// <summary>
/// Serializes the result into a byte array.
/// </summary>
/// <returns></returns>
internal byte[] GetBytes()
{
MemoryStream stream = new MemoryStream();
BinaryWriter writer = new BinaryWriter(stream);
try
{
writer.Write((int)_mode);
if (_mode == ResultType.UpdateCount)
{
writer.Write(_updateCount);
}
else if (_mode == ResultType.Error)
{
writer.Write(_error);
}
else
{
int l = _columnCount;
writer.Write(l);
Record n = _root;
for (int i = 0; i < l; i++)
{
writer.Write((int)Type[i]);
writer.Write(Label[i]);
writer.Write(Table[i]);
writer.Write(Name[i]);
}
while (n != null)
{
Column.WriteData(writer, l, Type, n.Data);
n = n.Next;
}
}
return(stream.ToArray());
}
catch (Exception e)
{
LogHelper.Publish("Unexpected error on getBytes.", e);
throw TracingHelper.Error(TracingHelper.TRANSFER_CORRUPTED);
}
}
/// <summary>
/// Flush method declaration.
/// The flush method saves all cached data to the file, saves the free position
/// and closes the file.
/// </summary>
public void Flush()
{
try
{
_fileStream.Seek(FREE_POS_POS, SeekOrigin.Begin);
BinaryWriter b = new BinaryWriter(_fileStream);
b.Write(_freePos);
SaveAll();
_fileStream.Close();
}
catch (Exception e)
{
throw TracingHelper.Error(TracingHelper.FILE_IO_ERROR, "error " + e + " closing " + _name);
}
}
/// <summary>
/// Gets a declare object value.
/// </summary>
/// <param name="name"></param>
internal object GetDeclareValue(string name)
{
TracingHelper.Check(!_closed, TracingHelper.CONNECTION_IS_CLOSED);
Declare declare = _variables[name] as Declare;
if (declare != null)
{
return(declare.Value);
}
else
{
throw TracingHelper.Error(TracingHelper.VARIABLE_NOT_DECLARED);
}
}
/// <summary>
/// Sets a declare object value.
/// </summary>
/// <param name="name"></param>
/// <param name="value"></param>
internal void SetDeclareValue(string name, object value)
{
TracingHelper.Check(!_closed, TracingHelper.CONNECTION_IS_CLOSED);
Declare declare = _variables[name] as Declare;
if (declare != null)
{
declare.Value = value;
declare.Expression.SetArg(value);
}
else
{
throw TracingHelper.Error(TracingHelper.VARIABLE_NOT_DECLARED);
}
}
internal void LinkTable(Table table)
{
string name = table.Name;
for (int i = 0; i < _table.Count; i++)
{
Table o = (Table)_table[i];
if (o.Name.Equals(name))
{
throw TracingHelper.Error(TracingHelper.TABLE_ALREADY_EXISTS, name);
}
}
_table.Add(table);
}
private bool ProcessTrueOrFalse(Tokenizer tokenizer)
{
string sToken = tokenizer.GetString();
switch (sToken)
{
case "TRUE":
return(true);
case "FALSE":
return(false);
default:
throw TracingHelper.Error(TracingHelper.UnexpectedToken, sToken);
}
}
/// <summary>
/// Sum two objects.
/// </summary>
/// <param name="one"></param>
/// <param name="two"></param>
/// <param name="type"></param>
/// <returns></returns>
internal static object Sum(object one, object two, ColumnType type)
{
if (one == null)
{
return(two);
}
if (two == null)
{
return(one);
}
switch (type)
{
case ColumnType.Null:
return(null);
case ColumnType.Integer:
return(((int)one) + ((int)two));
case ColumnType.Float:
case ColumnType.Real:
return(((float)one) + ((float)two));
case ColumnType.DbDouble:
return(((double)one) + ((double)two));
case ColumnType.Numeric:
case ColumnType.DbDecimal:
return(((decimal)one) + ((decimal)two));
case ColumnType.TinyInt:
return(((byte)one) + ((byte)two));
case ColumnType.SmallInt:
return(((short)one) + ((short)two));
case ColumnType.BigInt:
return(((long)one) + ((long)two));
default:
TracingHelper.Error(TracingHelper.SUM_OF_NON_NUMERIC);
break;
}
return(null);
}
/// <summary>
/// Deserialize method declaration.
/// This method returns the array of bytes stored in the instance of
/// ByteArray class as an object instance.
/// </summary>
/// <returns>The deserialized object</returns>
public static object Deserialize(byte[] data)
{
try
{
#if !POCKETPC
MemoryStream ms = new MemoryStream(data);
BinaryFormatter b = new BinaryFormatter();
return(b.Deserialize(ms));
#else
throw new NotSupportedException();
#endif
}
catch (Exception e)
{
throw TracingHelper.Error(TracingHelper.SERIALIZATION_FAILURE, e.Message);
}
}
/// <summary>
/// CreateUser method declaration.
/// This method is used to create a new user. The collection of users
/// is first checked for a duplicate name, and an exception will be thrown
/// if a user of the same name already exists.
/// </summary>
/// <param name="name">User login</param>
/// <param name="password">Plaintext password</param>
/// <param name="admin">Is this a database admin user?</param>
/// <returns>An instance of the newly created User object</returns>
public User CreateUser(string name, string password, bool admin)
{
for (int i = 0; i < uUser.Count; i++)
{
User u = (User)uUser[i];
if (u != null && u.Name.Equals(name))
{
throw TracingHelper.Error(TracingHelper.USER_ALREADY_EXISTS, name);
}
}
User unew = new User(name, password, admin, uPublic);
uUser.Add(unew);
return(unew);
}
