gserialized_cmp()

int gserialized_cmp	(	const GSERIALIZED *	g1,
		const GSERIALIZED *	g2
	)

Return -1 if g1 is "less than" g2, 1 if g1 is "greater than" g2 and 0 if g1 and g2 are the "same".

Equality is evaluated with a memcmp and size check. So it is possible that two identical objects where one lacks a bounding box could be evaluated as non-equal initially. Greater and less than are evaluated by calculating a sortable key from the center point of the object bounds.

Definition at line 294 of file g_serialized.c.

References GSERIALIZED::data, floatuint::f, GSERIALIZED::flags, FLAGS_GET_BBOX, FLAGS_GET_GEODETIC, gbox_get_sortable_hash(), gserialized_cmp_srid(), gserialized_get_gbox_p(), gserialized_get_type(), gserialized_header_size(), LW_FAILURE, POINTTYPE, GSERIALIZED::size, SIZE_GET, floatuint::u, uint32_interleave_2(), GBOX::xmax, GBOX::xmin, GBOX::ymax, and GBOX::ymin.

Referenced by geography_cmp(), geography_eq(), geography_ge(), geography_gt(), geography_le(), geography_lt(), lwgeom_cmp(), lwgeom_eq(), lwgeom_ge(), lwgeom_gt(), lwgeom_le(), and lwgeom_lt().

{
        int g1_is_empty, g2_is_empty, cmp;
        GBOX box1, box2;
        uint64_t hash1, hash2;
        size_t sz1 = SIZE_GET(g1->size);
        size_t sz2 = SIZE_GET(g2->size);
        union floatuint x, y;

        /*
        * For two non-same planar points, we can skip a lot of machinery.
        */
        if (
                sz1 > 16 && // 16 is size of EMPTY, if it's larger - it has coordinates
                sz2 > 16 &&
                *(uint32_t*)(g1->data) == POINTTYPE &&
                *(uint32_t*)(g2->data) == POINTTYPE &&
                !FLAGS_GET_BBOX(g1->flags) &&
                !FLAGS_GET_GEODETIC(g1->flags) &&
                !FLAGS_GET_BBOX(g2->flags) &&
                !FLAGS_GET_GEODETIC(g2->flags)
        )
        {
                double *dptr = (double*)(g1->data);
                x.f = 2.0 * dptr[1];
                y.f = 2.0 * dptr[2];
                hash1 = uint32_interleave_2(x.u, y.u);

                dptr = (double*)(g2->data);
                x.f = 2.0 * dptr[1];
                y.f = 2.0 * dptr[2];
                hash2 = uint32_interleave_2(x.u, y.u);

                if ( hash1 > hash2 )
                        return 1;
                if ( hash1 < hash2 )
                        return -1;

                // if hashes happen to be the same, go to full compare.
        }

        size_t hsz1 = gserialized_header_size(g1);
        size_t hsz2 = gserialized_header_size(g2);

        uint8_t *b1 = (uint8_t*)g1 + hsz1;
        uint8_t *b2 = (uint8_t*)g2 + hsz2;
        size_t bsz1 = sz1 - hsz1;
        size_t bsz2 = sz2 - hsz2;
        size_t bsz = bsz1 < bsz2 ? bsz1 : bsz2;

        int cmp_srid = gserialized_cmp_srid(g1, g2);

        g1_is_empty = (gserialized_get_gbox_p(g1, &box1) == LW_FAILURE);
        g2_is_empty = (gserialized_get_gbox_p(g2, &box2) == LW_FAILURE);

        /* Empty == Empty */
        if (g1_is_empty && g2_is_empty)
        {
                /* POINT EMPTY == POINT EMPTY */
                /* POINT EMPTY < LINESTRING EMPTY */
                uint32_t t1 = gserialized_get_type(g1);
                uint32_t t2 = gserialized_get_type(g2);
                return t1 == t2 ? 0 : (t1 < t2 ? -1 : 1);
        }

        /* Empty < Non-empty */
        if (g1_is_empty)
                return -1;

        /* Non-empty > Empty */
        if (g2_is_empty)
                return 1;

        /* Return equality for perfect equality only */
        cmp = memcmp(b1, b2, bsz);
        if ( bsz1 == bsz2 && cmp_srid == 0 && cmp == 0 )
                return 0;

        /* Using the centroids, calculate somewhat sortable */
        /* hash key. The key doesn't provide good locality over */
        /* the +/- boundary, but otherwise is pretty OK */
        hash1 = gbox_get_sortable_hash(&box1);
        hash2 = gbox_get_sortable_hash(&box2);

        if ( hash1 > hash2 )
                return 1;
        else if ( hash1 < hash2 )
                return -1;

        /* What, the hashes are equal? OK... sort on the */
        /* box minima */
        if (box1.xmin < box2.xmin)
                return -1;
        else if (box1.xmin > box2.xmin)
                return 1;

        if (box1.ymin < box2.ymin)
                return -1;
        else if (box1.ymin > box2.ymin)
                return 1;

        /* Still equal? OK... sort on the box maxima */
        if (box1.xmax < box2.xmax)
                return -1;
        else if (box1.xmax > box2.xmax)
                return 1;

        if (box1.ymax < box2.ymax)
                return -1;
        else if (box1.ymax > box2.ymax)
                return 1;

        /* Geeze! How about object size? Sort on that... */
        if (hsz1 < hsz2)
                return -1;
        else if (hsz1 > hsz2)
                return 1;

        /* OK fine, we'll sort on the memcmp just to be done with this */
        return cmp == 0 ? 0 : (cmp > 0 ? 1 : -1);
}

Here is the call graph for this function:

Here is the caller graph for this function: