dictionary.h File Reference

#include <Python.h>
#include <CoolKernel/ChannelSelection.h>
#include <CoolKernel/IObject.h>
#include <CoolKernel/IObjectIterator.h>
#include <CoolKernel/IFolder.h>
#include <CoolKernel/IDatabase.h>
#include <CoolKernel/IDatabaseSvc.h>
#include <CoolKernel/IRecordSelection.h>
#include <CoolKernel/FieldSelection.h>
#include <CoolApplication/DatabaseSvcFactory.h>
#include <string>
#include <vector>

Go to the source code of this file.

Classes
struct	quick_retrieve_dict::dict

Namespaces
	quick_retrieve_dict

Macros
#define	register
#define	likely(x)   __builtin_expect((x),1)
#define	unlikely(x)   __builtin_expect((x),0)

Functions
const cool::RecordSpecification	get_coracool_payload_spec (IDatabasePtr cooldb, const string &folder)
PyObject *	browse_coracool (IDatabasePtr cooldb, const string &folder, ValidityKey since, ValidityKey until, const ChannelSelection &cs=ChannelSelection::all(), const char *tag="", PyObject *to_fetch=NULL, PyObject *object_converter=NULL, PyObject *inner_object_converter=NULL, PyObject *iovkey_wrapper=NULL)
PyObject *	quick_retrieve (const IObjectIteratorPtr &objects, PyObject *object_converter, PyObject *to_fetch=NULL, const long max_records=-1, const bool with_channel=true, const bool loud=false, PyObject *iovkey_wrapper=NULL, PyObject *channel_name_mapping=NULL, const bool with_time=false, const bool as_unicode=false)
cool::FieldSelection *	make_fieldselection (const std::string &name, const cool::StorageType::TypeId typeId, cool::FieldSelection::Relation relation, PyObject *refValue)
vector< const cool::IRecordSelection * >	make_selection_vector ()

Macro Definition Documentation

likely

#define likely

(

x

)

__builtin_expect((x),1)

Definition at line 41 of file dictionary.h.

register

#define register

Definition at line 22 of file dictionary.h.

unlikely

#define unlikely

(

x

)

__builtin_expect((x),0)

Definition at line 42 of file dictionary.h.

Function Documentation

browse_coracool()

PyObject* browse_coracool	(	IDatabasePtr	cooldb,
		const string &	folder,
		ValidityKey	since,
		ValidityKey	until,
		const ChannelSelection &	cs = ChannelSelection::all(),
		const char *	tag = "",
		PyObject *	to_fetch = NULL,
		PyObject *	object_converter = NULL,
		PyObject *	inner_object_converter = NULL,
		PyObject *	iovkey_wrapper = NULL
	)

Definition at line 188 of file pythonic_coracool.cxx.

{
    // Browse CoraCool objects
    CoraCoolFolderPtr     coralFolder = fetch_coracool_folder(cooldb, folder);
    CoraCoolObjectIterPtr objects     = coralFolder->browseObjects(since, until, 
                                                                   cs, tag);
    
    // Number of attributes to be fetched
    const Py_ssize_t count = to_fetch ? PySequence_Size(to_fetch) : 0;
    
    PyObject* result = PyList_New(0); // List which is returned by this function
    bool first = true;                // Is this the first iteration?
    CoraCoolObject::const_iterator payload; // Current payload
    
    // List of functors which convert an Attribute into a python value
    vector<coral_attribute_fetcher_t> payload_fetchers; 
    
    // Loop over IoVs
    while (objects->hasNext())
    {
        const CoraCoolObjectPtr& object = objects->next();
        
        PyObject *py_payload_tuple = PyTuple_New(object->size());
        unsigned int payload_index = 0;
        
        // Loop over multiple payloads per record
        for (payload = object->begin(); 
             payload != object->end();
             ++payload, ++payload_index)
        {
            if (unlikely(first))
            {
                // On the first iteration, figure out the types and create
                // specialised functions for retrieving them
                first = false;
                if (!make_fetchers(to_fetch, *payload, payload_fetchers))
                    return NULL; // Failure, throw python exception from above
            }
        
            // Create a tuple for the payload and fill it from payload fetchers
            PyObject *py_payload = PyTuple_New(count);
            for (Py_ssize_t i = 0; i < count; i++)
                PyTuple_SET_ITEM(py_payload, i, payload_fetchers[i](*payload));
                
            py_payload = apply_function(inner_object_converter, py_payload);
            
            if (!py_payload)
            {
                // apply_function returned an error
                // We won't return the list to python so we need to tell python it
                // can be deleted
                Py_DECREF(py_payload_tuple);
                Py_DECREF(result);
                return NULL;
            }
                
            PyTuple_SET_ITEM(py_payload_tuple, payload_index, py_payload);
        }
        
        PyObject *one = PyTuple_New(4);
        
        PyTuple_SET_ITEM(one, 0, make_iov_key(iovkey_wrapper, object->since()));
        PyTuple_SET_ITEM(one, 1, make_iov_key(iovkey_wrapper, object->until()));
        
        PyTuple_SET_ITEM(one, 2, PyLong_FromLong(object->channelId()));
        
        // SET_ITEM steals reference, no decref needed
        PyTuple_SET_ITEM(one, 3, py_payload_tuple);
        
        one = apply_function(object_converter, one);
        if (!one)
        {
            // apply_function returned an error
            // We won't return the list to python so we need to tell python it
            // can be deleted
            Py_DECREF(result);
            return NULL;
        }
        
        PyList_Append(result, one);
        Py_DECREF(one);
    }
    
    return result;
}

get_coracool_payload_spec()

const cool::RecordSpecification get_coracool_payload_spec	(	IDatabasePtr	cooldb,
		const string &	folder
	)

Definition at line 174 of file pythonic_coracool.cxx.

{
    return fetch_coracool_folder(cooldb, folder)->payloadSpecification();
}

make_fieldselection()

cool::FieldSelection* make_fieldselection	(	const std::string &	name,
		const cool::StorageType::TypeId	typeId,
		cool::FieldSelection::Relation	relation,
		PyObject *	refValue
	)

Definition at line 53 of file quick_retrieve.cxx.

{    
    #define MAKE_FS(type, converter) \
        if (typeId == cool::StorageType::type) \
            return new cool::FieldSelection(name, typeId, relation, \
                static_cast<cool::type>(converter(refValue)));
    
    MAKE_FS(Bool,      PyLong_AsLong)
    MAKE_FS(Float,     PyFloat_AsDouble)
    MAKE_FS(Double,    PyFloat_AsDouble)
    
    MAKE_FS(UChar,     PyLong_AsUnsignedLong)
    MAKE_FS(Int16,     PyLong_AsLong)
    MAKE_FS(UInt16,    PyLong_AsUnsignedLong)
    MAKE_FS(Int32,     PyLong_AsLong)
    MAKE_FS(UInt32,    PyLong_AsUnsignedLong)
    MAKE_FS(Int64,     PyLong_AsLongLong)
    MAKE_FS(UInt63,    PyLong_AsUnsignedLongLong)
    
    MAKE_FS(String255, _PyUnicode_AsString)
    MAKE_FS(String4k,  _PyUnicode_AsString)
    MAKE_FS(String64k, _PyUnicode_AsString)
    MAKE_FS(String16M, _PyUnicode_AsString)
 
    //MAKE_FS(Blob16M,   PyString_AsString)
    //MAKE_FS(Blob64k,   PyString_AsString)
    throw (std::runtime_error("Unsupported cool type encountered in python conversion"));
}

make_selection_vector()

vector<const cool::IRecordSelection*> make_selection_vector

(

)

Definition at line 86 of file quick_retrieve.cxx.

{
    return vector<const cool::IRecordSelection*>();
 
}

quick_retrieve()

PyObject* quick_retrieve	(	const IObjectIteratorPtr &	objects,
		PyObject *	object_converter,
		PyObject *	to_fetch = NULL,
		const long	max_records = -1,
		const bool	with_channel = true,
		const bool	loud = false,
		PyObject *	iovkey_wrapper = NULL,
		PyObject *	channel_name_mapping = NULL,
		const bool	with_time = false,
		const bool	as_unicode = false
	)

Definition at line 219 of file quick_retrieve.cxx.

{
    IObjectIterator_Guard closeiterator_guard(objects);
    
    PyObject* result = PyList_New(0);
    
    const long long records = objects->size();
    const Py_ssize_t count = to_fetch ? PySequence_Size(to_fetch) : 0;
    const unsigned int fetch_start = 2 + with_channel + with_time;
    bool first = true;
    int j = 0;
    PyObject *py_datetime_class = NULL;
    
    vector<payload_fetcher_t> payload_fetchers;
    
    while (objects->goToNext())
    {
        const IObject& object = objects->currentRef();
        
        if (unlikely(first))
        {
            // On the first iteration, compute the types in to_fetch, and bind
            // them into the payload_fetchers.
            first = false;
            for (Py_ssize_t i = 0; i < count; i++)
            {
                PyObject *py_name = PySequence_GetItem(to_fetch, i);
                const char *name = _PyUnicode_AsString(py_name);
                const string type = (object.payload()
                                           .specification()[name]
                                           .storageType()
                                           .name());
                
                payload_fetcher_t pf = create_payload_fetcher(name, type, 
                                                              as_unicode);
                auto pff = pf.target<PyObject* (*)(const IObject&)>();
                if ( pff && *pff == &no_conversion_available)
                    return NULL;
                payload_fetchers.push_back(pf);
                Py_DECREF(py_name);
            }
            
            if (with_time)
            {
                PyObject *py_datetime_module = PyImport_ImportModule("datetime");
                if (!py_datetime_module)
                    throw (std::runtime_error("Could not import python datetime_module"));
                
                py_datetime_class = PyObject_GetAttrString(py_datetime_module,
                                                           "datetime"); 
                
                Py_DECREF(py_datetime_module);
            }
        }
        
        PyObject *one = PyTuple_New(fetch_start + count);
        
        // Fetch (since, until, channel[optional])
        
        PyTuple_SET_ITEM(one, 0, make_iov_key(iovkey_wrapper, object.since()));
        PyTuple_SET_ITEM(one, 1, make_iov_key(iovkey_wrapper, object.until()));
 
        if (with_time)
        {
            const ITime& t = object.insertionTime();
            static const char * const argtypes = const_cast<char *>("iiiiiil");
            
            PyObject *py_record_time = 
                PyObject_CallFunction(py_datetime_class, argtypes, 
                    t.year(), t.month(), t.day(), 
                    t.hour(), t.minute(), t.second(), t.nanosecond() / 1000);
                    
            PyTuple_SetItem(one, 2, py_record_time);
        }
        
        if (with_channel)
        {
            if (channel_name_mapping)
            {
                // Use a channel name if it is available, otherwise fall back
                // to standard channelid.
                PyObject *channelId = PyLong_FromUnsignedLong(object.channelId());
                PyObject *channelName = PyDict_GetItem(channel_name_mapping,    
                                                       channelId);
                if (channelName)
                {
                    Py_INCREF(channelName);
                    Py_DECREF(channelId);
                    PyTuple_SET_ITEM(one, 2+with_time, channelName);
                } else
                    PyTuple_SET_ITEM(one, 2+with_time, channelId);
                
            } else
                PyTuple_SET_ITEM(one, 2+with_time, 
                                 PyLong_FromLong(object.channelId()));
        }
        
        // Fetch the objects specified in to_fetch
        for (Py_ssize_t i = 0; i < count; i++)
            PyTuple_SET_ITEM(one, fetch_start + i, payload_fetchers[i](object));
        
        one = apply_function(object_converter, one);
        if (!one)
        {
            // apply_function returned an error
            // We won't return the list to python so we need to tell python it
            // can be deleted
            Py_DECREF(result);
            return NULL;
        }
        
        PyList_Append(result, one);
        Py_DECREF(one);
        
        // Print status if loud is active
        if (unlikely(loud && ((++j) % 1000 == 0)))
        {
            cout << "Progress: " << j << " / " << records << "\r";
            cout.flush();
        }
        
        if (unlikely(max_records > 0 && j >= max_records))
            break;
    }
    
    if (loud)
        cout << "Done fetching " << j << " records.\x1B[K" << endl;
    
    if (py_datetime_class)
    {
        Py_DECREF(py_datetime_class);
    }
    
    return result;
}