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.

{
        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 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 &&
                !FLAGS_GET_BBOX(g1->flags) &&
                !FLAGS_GET_BBOX(g2->flags) &&
                gserialized_get_type(g1) == POINTTYPE &&
                gserialized_get_type(g2) == POINTTYPE
        )
        {
                double *dptr = (double*)(g1->data + sizeof(double));
                x.f = 2.0 * dptr[0];
                y.f = 2.0 * dptr[1];
                hash1 = uint32_interleave_2(x.u, y.u);
 
                dptr = (double*)(g2->data + sizeof(double));
                x.f = 2.0 * dptr[0];
                y.f = 2.0 * dptr[1];
                hash2 = uint32_interleave_2(x.u, y.u);
 
                /* If the SRIDs are the same, we can use hash inequality */
                /* to jump us out of this function early. Otherwise we still */
                /* have to do the full calculation */
                if ( gserialized_cmp_srid(g1, g2) == 0 )
                {
                        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 < Non-empty */
        if (g1_is_empty && !g2_is_empty)
                return -1;
 
        /* Non-empty > Empty */
        if (!g1_is_empty && 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;
 
        if (!g1_is_empty && !g2_is_empty)
        {
                /* 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;
        }
 
        /* Prefix comes before longer one. */
        if (bsz1 != bsz2 && cmp == 0)
        {
                if (bsz1 < bsz2)
                        return -1;
                else if (bsz1 > bsz2)
                        return 1;
        }
        return cmp > 0 ? 1 : -1;
}

References GSERIALIZED::data, GSERIALIZED::flags, FLAGS_GET_BBOX, gbox_get_sortable_hash(), gserialized_cmp_srid(), gserialized_get_gbox_p(), gserialized_get_type(), gserialized_header_size(), LW_FAILURE, POINTTYPE, GSERIALIZED::size, SIZE_GET, uint32_interleave_2(), pixval::x, GBOX::xmax, GBOX::xmin, pixval::y, 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().

Here is the call graph for this function:

Here is the caller graph for this function: