Example #1
0
        internal string GetRecord(string Id)
        {
            FlaimError.Error rc = FlaimError.Error.FERR_OK;
            char []          Buffer;
            int length = 4096;

            do
            {
                Buffer = new char[length];
                rc     = FWGetObject(pStore, Id, ref length, Buffer);
            } while (rc == FlaimError.Error.FERR_MEM);

            if (FlaimError.IsError(rc) && rc != FlaimError.Error.FERR_NOT_FOUND)
            {
                throw FlaimError.GetException(rc);
            }

            if (length > 0)
            {
                return(new string(Buffer, 0, length));
            }
            else
            {
                return(null);
            }
        }
Example #2
0
        /// <summary>
        /// Called to Delete a record container.
        /// This call is deep (all records contained are deleted).
        /// </summary>
        /// <param name="name">The name of the container.</param>
        internal FlaimError.Error DeleteContainer(string name)
        {
            FlaimError.Error rc = FlaimError.Error.FERR_OK;
            try
            {
                Query      query   = new Query(name, BaseSchema.CollectionId, SearchOp.Exists, name, Syntax.String);
                IResultSet results = Search(query);
                char []    buffer  = new char[4096];
                int        count;

                while ((count = results.GetNext(ref buffer)) != 0)
                {
                    XmlDocument delDoc = new XmlDocument();
                    delDoc.LoadXml(new string(buffer, 0, count));
                    rc = CommitRecords(name, null, delDoc);
                }
            }
            catch
            {
                if (FlaimError.IsSuccess(rc))
                {
                    rc = FlaimError.Error.FERR_FAILURE;
                }
            }
            return(rc);
        }
Example #3
0
        internal FlaimError.Error CreateObject(FlaimRecord record, int flmId, out bool usedId)
        {
            FlaimError.Error rc;
            int isNew;

            usedId = false;

            rc = FWCreateObject(pStore, record.Name, record.Id, record.Type, out isNew, flmId, out record.pRecord);

            if (FlaimError.IsSuccess(rc))
            {
                if (isNew == 1 && flmId != 0)
                {
                    usedId = true;
                }
                // Now Create all of the properties.
                foreach (Property property in record)
                {
                    rc = FWSetProperty(record.pRecord, property.Name, property.Type, property.Value, property.Flags);
                    if (FlaimError.IsError(rc))
                    {
                        break;
                    }
                }

                FWCloseObject(record.pRecord, FlaimError.IsSuccess(rc) ? false : true);
            }

            return(rc);
        }
Example #4
0
 /// <summary>
 /// Called to Create a new Collection Store at the specified location.
 /// </summary>
 public void CreateStore()
 {
     FlaimError.Error rc = Flaim.CreateStore();
     if (FlaimError.IsError(rc))
     {
         throw (new CreateException("Flaim DB", FlaimError.GetException(rc)));
     }
 }
Example #5
0
 /// <summary>
 /// Called to Delete the opened CollectionStore.
 /// </summary>
 public void DeleteStore()
 {
     FlaimError.Error rc = Flaim.DeleteStore();
     if (FlaimError.IsError(rc))
     {
         // We had an error the store was not deleted.
         throw(new DeleteException("Flaim DB", FlaimError.GetException(rc)));
     }
 }
Example #6
0
 /// <summary>
 /// Used to Create, Modify or Delete records from the store.
 /// </summary>
 /// <param name="container">The container that the commit applies to.</param>
 /// <param name="createDoc">The records to create or modify.</param>
 /// <param name="deleteDoc">The records to delete.</param>
 public void CommitRecords(string container, XmlDocument createDoc, XmlDocument deleteDoc)
 {
     FlaimError.Error rc = Flaim.CommitRecords(container, createDoc, deleteDoc);
     if (FlaimError.IsError(rc))
     {
         // We had an error the commit was not successful.
         throw(new CommitException(createDoc, deleteDoc, FlaimError.GetException(rc)));
     }
 }
Example #7
0
 /// <summary>
 /// Called to Delete a record container.
 /// This call is deep (all records contained are deleted).
 /// </summary>
 /// <param name="name">The name of the container.</param>
 public void DeleteContainer(string name)
 {
     FlaimError.Error rc = Flaim.DeleteContainer(name);
     if (FlaimError.IsError(rc))
     {
         // We had an error the container was not deleted.
         throw(new DeleteException(name, FlaimError.GetException(rc)));
     }
 }
Example #8
0
        /// <summary>
        /// Method used to search for Records using the specified query.
        /// </summary>
        /// <param name="query">Query used for this search</param>
        /// <returns></returns>
        internal IResultSet Search(Query query)
        {
            FlaimResultSet resultSet;

            FlaimError.Error rc = Flaim.Search(query, out resultSet, this);
            if (FlaimError.IsError(rc))
            {
                throw new SearchException(query.ToString());
            }
            return(resultSet);
        }
Example #9
0
 internal FlaimError.Error OpenStore()
 {
     FlaimError.Error rc = FlaimError.Error.FERR_FAILURE;
     lock (handleTable)
     {
         rc = FWOpenStore(DbPath, out pStore, out pDB);
         if (FlaimError.IsSuccess(rc))
         {
             handleTable.Add(pStore, pStore);
             opened = true;
         }
     }
     return(rc);
 }
Example #10
0
        /// <summary>
        /// Called to Open an existing Collection store at the specified location.
        /// </summary>
        internal FlaimError.Error OpenStore()
        {
            FlaimError.Error rc = FlaimError.Error.FERR_FAILURE;

            lock (typeof(FlaimServer))
            {
                rc = Flaim.OpenStore();
                if (FlaimError.IsSuccess(rc))
                {
                    AlreadyDisposed = false;
                }
            }
            return(rc);
        }
Example #11
0
 /// <summary>
 /// Called to Open an existing Collection store at the specified location.
 /// </summary>
 public void OpenStore()
 {
     FlaimError.Error rc = Flaim.OpenStore();
     if (FlaimError.IsError(rc))
     {
         if (rc == FlaimError.Error.FERR_IO_PATH_NOT_FOUND)
         {
             // The files do not exist.
             throw new ApplicationException();
         }
         else
         {
             // We had an error the store was not opened.
             throw(new OpenException("Flaim DB", FlaimError.GetException(rc)));
         }
     }
 }
Example #12
0
 /// <summary>
 /// Called to Create a new Collection Store at the specified location.
 /// </summary>
 internal FlaimError.Error CreateStore()
 {
     FlaimError.Error rc = FlaimError.Error.FERR_FAILURE;
     lock (typeof(FlaimServer))
     {
         if (!Directory.Exists(DbPath))
         {
             // Create the store
             rc = Flaim.CreateStore();
             if (FlaimError.IsSuccess(rc))
             {
                 // Set the version.
                 AlreadyDisposed = false;
             }
         }
     }
     return(rc);
 }
Example #13
0
        internal FlaimError.Error DeleteStore()
        {
            FlaimError.Error rc = FlaimError.Error.FERR_FAILURE;
            // Close the current handle.
            CloseStore();

            // Now force the other instances closed.
            lock (handleTable)
            {
                foreach (IntPtr p in handleTable.Keys)
                {
                    FWCloseStore(p);
                }
                handleTable.Clear();
                rc = FWDeleteStore(DbPath);
                if (FlaimError.IsSuccess(rc))
                {
                    opened = false;
                }
            }
            pDB = IntPtr.Zero;
            return(rc);
        }
Example #14
0
        /// <summary>
        /// Used to Create, Modify or Delete records from the store.
        /// </summary>
        /// <param name="container">The container that the commit applies to.</param>
        /// <param name="createDoc">The records to create or modify.</param>
        /// <param name="deleteDoc">The records to delete.</param>
        internal FlaimError.Error CommitRecords(string container, XmlDocument createDoc, XmlDocument deleteDoc)
        {
            FlaimError.Error rc    = FlaimError.Error.FERR_OK;
            Flaim4           flaim = this.Flaim;

            try
            {
                Flaim.BeginTrans();
                try
                {
                    if (createDoc != null)
                    {
                        XmlNodeList recordList = createDoc.DocumentElement.SelectNodes(XmlTags.ObjectTag);
                        foreach (XmlElement recordEl in recordList)
                        {
                            bool reuseId;
                            int  flmId = 0;
                            if (IdQueue.Count != 0)
                            {
                                flmId   = (int)IdQueue.Peek();
                                reuseId = true;
                            }

                            FlaimRecord record = new FlaimRecord(recordEl);
                            rc = flaim.CreateObject(record, flmId, out reuseId);

                            if (FlaimError.IsSuccess(rc))
                            {
                                if (reuseId)
                                {
                                    flmId = (int)IdQueue.Dequeue();
                                }
                            }
                            else
                            {
                                throw FlaimError.GetException(rc);
                            }
                        }
                    }
                    if (deleteDoc != null)
                    {
                        XmlNodeList recordList = deleteDoc.DocumentElement.SelectNodes(XmlTags.ObjectTag);
                        foreach (XmlElement recordEl in recordList)
                        {
                            int         flmId;
                            FlaimRecord record = new FlaimRecord(recordEl);
                            rc = flaim.DeleteObject(record.Id, out flmId);
                            if (FlaimError.IsSuccess(rc))
                            {
                                IdQueue.Enqueue(flmId);
                            }
                            else if (rc != FlaimError.Error.FERR_NOT_FOUND)
                            {
                                throw FlaimError.GetException(rc);
                            }
                            else
                            {
                                rc = FlaimError.Error.FERR_OK;
                            }
                        }
                    }
                    Flaim.EndTrans();
                }
                catch
                {
                    Flaim.AbortTrans();
                }
            }
            catch
            {
                if (FlaimError.IsSuccess(rc))
                {
                    rc = FlaimError.Error.FERR_FAILURE;
                }
            }
            return(rc);
        }
Example #15
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="queryArray">Queries used for this search</param>
        /// <param name="results"></param>
        /// <param name="flaimServer"></param>
        /// <returns></returns>
        internal FlaimError.Error MQSearch(Query[] queryArray, out FlaimResultSet results, FlaimServer flaimServer)
        {
            FlaimError.Error rc = FlaimError.Error.FERR_OK;

            results = null;
            int    count         = 0;
            IntPtr pFlaimResults = new IntPtr();

            int[]    op            = new int[queryArray.Length];
            string[] sValue        = new String[queryArray.Length];
            string[] sName         = new String[queryArray.Length];
            string[] sType         = new String[queryArray.Length];
            int      caseSensitive = 0;
            int      arrayIndex    = 0;

            foreach (Query qry in queryArray)
            {
                sValue[arrayIndex] = String.Copy(qry.Value);
                sName[arrayIndex]  = String.Copy(qry.Property);
                sType[arrayIndex]  = String.Copy(qry.Type.ToString());
                switch (qry.Operation)
                {
                case SearchOp.Equal:
                    op[arrayIndex] = 103;                                       // FLM_EQ_OP
                    break;

                case SearchOp.Not_Equal:
                    op[arrayIndex] = 108;                                       // FLM_NE_OP
                    break;

                case SearchOp.Begins:
                    op[arrayIndex] = 105;                                       // FLM_MATCH_BEGIN_OP
                    break;

                case SearchOp.Ends:
                    op[arrayIndex] = 106;                                       // FLM_MATCH_END_OP
                    break;

                case SearchOp.Contains:
                    op[arrayIndex] = 107;                                       // FLM_CONTAINS_OP
                    break;

                case SearchOp.Greater:
                    op[arrayIndex] = 111;                                       // FLM_GT_OP
                    break;

                case SearchOp.Less:
                    op[arrayIndex] = 109;                                       // FLM_LT_OP
                    break;

                case SearchOp.Greater_Equal:
                    op[arrayIndex] = 112;                                       // FLM_GE_OP
                    break;

                case SearchOp.Less_Equal:
                    op[arrayIndex] = 110;                                       // FLM_LE_OP
                    break;

                case SearchOp.Exists:
                    switch (qry.Type)
                    {
                    case Syntax.Boolean:
                        op[arrayIndex]     = 112;
                        sValue[arrayIndex] = "0";
                        break;

                    case Syntax.Byte:
                    case Syntax.Char:
                    case Syntax.DateTime:
                    case Syntax.Int16:
                    case Syntax.Int32:
                    case Syntax.Int64:
                    case Syntax.SByte:
                    case Syntax.TimeSpan:
                    case Syntax.UInt16:
                    case Syntax.UInt32:
                    case Syntax.UInt64:
                        op[arrayIndex]     = 111;                                               // FLM_GT_OP
                        sValue[arrayIndex] = Int64.MinValue.ToString();
                        break;

                    case Syntax.Relationship:
                    case Syntax.String:
                    case Syntax.Uri:
                    case Syntax.XmlDocument:
                        op[arrayIndex]     = 105;
                        sValue[arrayIndex] = "*";
                        break;

                    case Syntax.Single:
                        op[arrayIndex]     = 111;                                               // FLM_GT_OP
                        sValue[arrayIndex] = Single.MinValue.ToString();
                        break;
                    }
                    break;

                case SearchOp.CaseEqual:
                    caseSensitive  = 1;
                    op[arrayIndex] = 103;                                       // FLM_EQ_OP
                    break;
                }

                if (arrayIndex++ >= 3)
                {
                    break;
                }
            }


            if (op[0] != 0)
            {
                if (queryArray.Length == 1)
                {
                    rc = FWMQSearch(pStore, queryArray[0].CollectionId, sName[0], op[0], sValue[0], sType[0], null, 0, null, null, null, 0, null, null, null, 0, null, null, (int)1, caseSensitive, out count, out pFlaimResults);
                }
                else if (queryArray.Length == 2)
                {
                    rc = FWMQSearch(pStore, queryArray[0].CollectionId, sName[0], op[0], sValue[0], sType[0], sName[1], op[1], sValue[1], sType[1], null, 0, null, null, null, 0, null, null, (int)2, caseSensitive, out count, out pFlaimResults);
                }
                else if (queryArray.Length == 3)
                {
                    rc = FWMQSearch(pStore, queryArray[0].CollectionId, sName[0], op[0], sValue[0], sType[0], sName[1], op[1], sValue[1], sType[1], sName[2], op[2], sValue[2], sType[2], null, 0, null, null, (int)3, caseSensitive, out count, out pFlaimResults);
                }
                else if (queryArray.Length == 4)
                {
                    rc = FWMQSearch(pStore, queryArray[0].CollectionId, sName[0], op[0], sValue[0], sType[0], sName[1], op[1], sValue[1], sType[1], sName[2], op[2], sValue[2], sType[2], sName[3], op[3], sValue[3], sType[3], (int)4, caseSensitive, out count, out pFlaimResults);
                }
                if (FlaimError.IsSuccess(rc))
                {
                    results = new FlaimResultSet(pFlaimResults, count, flaimServer);
                }
            }

            return(rc);
        }
Example #16
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="query"></param>
        /// <param name="results"></param>
        /// <param name="flaimServer"></param>
        /// <returns></returns>
        internal FlaimError.Error Search(Query query, out FlaimResultSet results, FlaimServer flaimServer)
        {
            FlaimError.Error rc = FlaimError.Error.FERR_OK;

            results = null;
            int    count;
            IntPtr pFlaimResults;
            int    op            = 0;
            string sValue        = query.Value;
            int    caseSensitive = 0;

            switch (query.Operation)
            {
            case SearchOp.Equal:
                op = 103;                                       // FLM_EQ_OP
                break;

            case SearchOp.Not_Equal:
                op = 108;                                       // FLM_NE_OP
                break;

            case SearchOp.Begins:
                op = 105;                                       // FLM_MATCH_BEGIN_OP
                break;

            case SearchOp.Ends:
                op = 106;                                       // FLM_MATCH_END_OP
                break;

            case SearchOp.Contains:
                op = 107;                                       // FLM_CONTAINS_OP
                break;

            case SearchOp.Greater:
                op = 111;                                       // FLM_GT_OP
                break;

            case SearchOp.Less:
                op = 109;                                       // FLM_LT_OP
                break;

            case SearchOp.Greater_Equal:
                op = 112;                                       // FLM_GE_OP
                break;

            case SearchOp.Less_Equal:
                op = 110;                                       // FLM_LE_OP
                break;

            case SearchOp.Exists:
                switch (query.Type)
                {
                case Syntax.Boolean:
                    op     = 112;
                    sValue = "0";
                    break;

                case Syntax.Byte:
                case Syntax.Char:
                case Syntax.DateTime:
                case Syntax.Int16:
                case Syntax.Int32:
                case Syntax.Int64:
                case Syntax.SByte:
                case Syntax.TimeSpan:
                case Syntax.UInt16:
                case Syntax.UInt32:
                case Syntax.UInt64:
                    op     = 111;                                               // FLM_GT_OP
                    sValue = Int64.MinValue.ToString();
                    break;

                case Syntax.Relationship:
                case Syntax.String:
                case Syntax.Uri:
                case Syntax.XmlDocument:
                    op     = 105;
                    sValue = "*";
                    break;

                case Syntax.Single:
                    op     = 111;                                               // FLM_GT_OP
                    sValue = Single.MinValue.ToString();
                    break;
                }
                break;

            case SearchOp.CaseEqual:
                caseSensitive = 1;
                op            = 103;                            // FLM_EQ_OP
                break;
            }

            if (op != 0)
            {
                rc = FWSearch(pStore, query.CollectionId, query.Property, op, sValue, query.Type.ToString(), caseSensitive, out count, out pFlaimResults);
                if (FlaimError.IsSuccess(rc))
                {
                    results = new FlaimResultSet(pFlaimResults, count, flaimServer);
                }
            }

            return(rc);
        }