tuple.cpp File Reference

Go to the source code of this file.

Functions
void	tupleFiddle ()
int	main (int argc, char *argv[])
boost::unit_test_framework::test_suite *	init_unit_test_suite (int, char **)
Variables
int const	bufferlen = 8
int const	num = 5

---

Function Documentation

boost::unit_test_framework::test_suite* init_unit_test_suite	(	int	,
		char **
	)

Definition at line 165 of file tuple.cpp.

{
    return NULL;
}

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 159 of file tuple.cpp.

References tupleFiddle().

{
    tupleFiddle();
    return 0;
}

void tupleFiddle

(

)

Definition at line 45 of file tuple.cpp.

References bufferlen, TupleAccessor::compute(), FixedBuffer, TupleAccessor::getMaxByteCount(), StandardTypeDescriptorFactory::newDataType(), num, TupleDatum::pData, TuplePrinter::print(), TupleAccessor::setCurrentTupleBuf(), STANDARD_TYPE_INT_32, STANDARD_TYPE_REAL, STANDARD_TYPE_UINT_8, STANDARD_TYPE_VARCHAR, TUPLE_FORMAT_ALL_FIXED, and TupleAccessor::unmarshal().

Referenced by main().

{
    bool isNullable = true;    // Can tuple contain nulls?
    int i;

    TupleDescriptor tupleDesc;
    tupleDesc.clear();

    // Build up a description of what we'd like the tuple to look like
    StandardTypeDescriptorFactory typeFactory;
    for (i = 0; i < num; i++) {
        StoredTypeDescriptor const &typeDesc =
            typeFactory.newDataType(STANDARD_TYPE_VARCHAR);
        tupleDesc.push_back(
            TupleAttributeDescriptor(
                typeDesc,
                isNullable,
                bufferlen));
    }
    for (i = 0; i < num; i++) {
        StoredTypeDescriptor const &typeDesc =
            typeFactory.newDataType(STANDARD_TYPE_INT_32);
        tupleDesc.push_back(TupleAttributeDescriptor(typeDesc, isNullable));
    }
    for (i = 0; i < num; i++) {
        StoredTypeDescriptor const &typeDesc =
            typeFactory.newDataType(STANDARD_TYPE_UINT_8);
        tupleDesc.push_back(TupleAttributeDescriptor(typeDesc, isNullable));
    }
    for (i = 0; i < num; i++) {
        StoredTypeDescriptor const &typeDesc =
            typeFactory.newDataType(STANDARD_TYPE_REAL);
        tupleDesc.push_back(TupleAttributeDescriptor(typeDesc, isNullable));
    }

    // Create a tuple accessor from the description
    //
    // Note: Must use an ALL_FIXED accessor when creating a tuple out of
    // the air like this, otherwise unmarshal() does not know what to
    // do. If you need a STANDARD type tuple with variable-lengty
    // fields, it has to be built as a copy.
    TupleAccessor tupleAccessorFixed;
    tupleAccessorFixed.compute(tupleDesc, TUPLE_FORMAT_ALL_FIXED);

    // Allocate memory for the tuple
    boost::scoped_array<FixedBuffer>
        pTupleBufFixed(new FixedBuffer[tupleAccessorFixed.getMaxByteCount()]);

    // Link memory to accessor
    tupleAccessorFixed.setCurrentTupleBuf(pTupleBufFixed.get(), false);

    // Create a vector of TupleDatum objects based on the description we built
    TupleData tupleDataFixed(tupleDesc);

    // Do something mysterious. Probably binding pointers in the accessor to
    // items in the TupleData vector
    tupleAccessorFixed.unmarshal(tupleDataFixed);

    TupleData::iterator itr = tupleDataFixed.begin();

    TupleDatum pDatum;
    PBuffer pData;

    for (i = 0; i < num; i++, itr++) {
        char buf[bufferlen * 10];
        sprintf(buf,"%d-A-%d-B-%d-C-", i, i, i); // longer than buflen
        strncpy(
            (reinterpret_cast<char *>(const_cast<PBuffer>(itr->pData))),
            buf, bufferlen);
    }
    for (i = 0; i < num; i++, itr++) {
        // exploded form
        pDatum = *itr;
        pData = const_cast<PBuffer>(pDatum.pData);
        *(reinterpret_cast<int32_t *>(pData)) = i;
    }
    for (i = 0; i < num; i++, itr++) {
        // condensed form
        *(reinterpret_cast<uint8_t *>(const_cast<PBuffer>(itr->pData))) = i;
    }
    for (i = 0; i < num; i++, itr++) {
        *(reinterpret_cast<float *>(const_cast<PBuffer>(itr->pData))) = i * 0.5;
    }

    // Print out the tuple
    TuplePrinter tuplePrinter;
    tuplePrinter.print(cout, tupleDesc, tupleDataFixed);
    cout << endl;

    // Create another TupleData object that will be nullable
    TupleData tupleDataNullable = tupleDataFixed;

    // null out last element of each type
    for (i = 1; i <= 3; i++) {
        tupleDataNullable[(i*num)-1].pData = NULL;
    }

    // Print out the nullable tuple
    tuplePrinter.print(cout, tupleDesc, tupleDataNullable);
    cout << endl;

    // Re-point second string to first string
    tupleDataNullable[1].pData = tupleDataNullable[0].pData;

    // Re-point third string to part way into first string
    tupleDataNullable[2].pData = (tupleDataNullable[0].pData + 1);

    // Print out the modified nullable tuple
    tuplePrinter.print(cout, tupleDesc, tupleDataNullable);
    cout << endl;

}

---

Variable Documentation

int const bufferlen = 8

Definition at line 41 of file tuple.cpp.

Referenced by tupleFiddle(), unitTestNullableLocal(), and unitTestPointer().

int const num = 5

Definition at line 42 of file tuple.cpp.

Referenced by tupleFiddle(), unitTestNullableLocal(), and unitTestPointer().

---