31 research outputs found

    Energy-level alignment at interfaces between manganese phthalocyanine and C60

    Get PDF
    We have used photoelectron spectroscopy to determine the energy-level alignment at organic heterojunctions made of manganese phthalocyanine (MnPc) and the fullerene C60. We show that this energy-level alignment depends upon the preparation sequence, which is explained by different molecular orientations. Moreover, our results demonstrate that MnPc/C60 interfaces are hardly suited for application in organic photovoltaic devices, since the energy difference of the two lowest unoccupied molecular orbitals (LUMOs) is rather small

    Charge transfer from and to manganese phthalocyanine: bulk materials and interfaces

    Get PDF
    Manganese phthalocyanine (MnPc) is a member of the family of transition-metal phthalocyanines, which combines interesting electronic behavior in the fields of organic and molecular electronics with local magnetic moments. MnPc is characterized by hybrid states between the Mn 3d orbitals and the π orbitals of the ligand very close to the Fermi level. This causes particular physical properties, different from those of the other phthalocyanines, such as a rather small ionization potential, a small band gap and a large electron affinity. These can be exploited to prepare particular compounds and interfaces with appropriate partners, which are characterized by a charge transfer from or to MnPc. We summarize recent spectroscopic and theoretical results that have been achieved in this regard

    Efficient Enumeration of Non-isomorphic Processing Trees

    Get PDF
    textabstractEnumeration of search spaces belonging to join queries, so far comprises large sets of isomorphic processing trees, i.e. trees that can be equalized by only commutative exchange of the input relations to the operators. Since these differences can be handled effectively by the costing method it is sufficient to focus on the enumeration of non-isomorphic processing trees only. This restriction reduces the size of the search space by factor 2^k, k being the number of operators. In this paper we present a technique that generates all non-isomorphic trees belonging to an arbitrarily shaped query graph. The algorithm generates sequences over the query graph's edges which are simultaneously turned into processing trees. During the incremental expansion of sequence prefixes the remaining edges are classified and only those not leading to isomorphic duplicates are appended. This incremental proceeding causes only little overhead leading to superior performance

    Dynamic Aspects of Query Processing in Parallel Database Systems

    No full text
    This paper reports ongoing work in developing a query representation method for the implementation of dynamic and parallel query processing in database systems. We present Stream Processing based Query Representation --- a concept derived from software engineering --- as powerful approach, which covers query representation from high-level query declaration to low-level procedural (parallel) execution plans. Hence, it is an ideal basis to extend the query processing component at any level, e.g. with new optimization techniques or dynamic execution methods

    Counting, Enumerating, and Sampling of Execution Plans in a Cost-Based Query Optimizer

    No full text
    Testing an SQL database system by running large sets of deterministic or stochastic SQL statements is common practice in commercial database development. However, code defects often remain undetected as the query optimizer's choice of an execution plan is not only depending on the query but strongly influenced by a large number of parameters describing the database and the hardware environment. Modifying these parameters in order to steer the optimizer to select other plans is di#cult since this means anticipating often complex search strategies implemented in the optimizer. In this paper we devise algorithms for counting, exhaustive generation, and uniform sampling of plans from the complete search space. Our techniques allow extensive validation of both generation of alternatives, and execution algorithms with plans other than the optimized one---if two candidate plans fail to produce the same results, then either the optimizer considered an invalid plan, or the execution ..

    Probabilistic Bottom-up Join Order Selection -- Breaking the Curse of NP-completeness

    Get PDF
    Join-ordering is known to be NP-complete and therefore a variety of heuristics have been devised to tackle large queries which are considered computational intractable otherwise. However, practitioners often point out that typical problem instances are not difficult to optimize at all. In this paper we address that seeming discrepancy. We present a probabilistic bottomup join-ordering technique that is distinguished by the high-quality results achieved, the extremely short running time and---most notable---its independence of the search space's size. The subsequent thorough analysis of the algorithm's principle confirm our experimental results

    Dynamic prioritization of database queries

    No full text
    Abstract-Enterprise database systems handle a variety of diverse query workloads that are of different importance to the business. For example, periodic reporting queries are usually mission critical whereas ad-hoc queries by analysts tend to be less crucial. It is desirable to enable database administrators to express (and modify) the importance of queries at a simple and intuitive level. The mechanism used to enforce these priorities must be robust, adaptive and efficient. In this paper, we present a mechanism that continuously determines and re-computes the ideal target velocity of concurrent database processes based on their run-time statistics to achieve this prioritization. In this scheme, every process autonomously adjusts its resource consumption using basic control theory principles. The self-regulating and decentralized design of the system enables effective prioritization even in the presence of exceptional situations, including software defects or unexpected/unplanned query termination with no measurable overhead. We have implemented this approach in Greenplum Parallel Database and demonstrate its effectiveness and general applicability in a series of experiments
    corecore