pg.ddx.io  pgsql-sql@postgresql.org mailing list archive  
help / color / mirror / Atom feed
Re: Btree index extension question
12+ messages / 5 participants
[nested] [flat]

* Re: Btree index extension question
@ 2002-03-15 17:06  Tom Lane <tgl@sss.pgh.pa.us>
  parent: Dmitry Tkach <dmitry@openratings.com>
  1 sibling, 1 reply; 12+ messages in thread

From: Tom Lane @ 2002-03-15 17:06 UTC (permalink / raw)
  To: Dmitry Tkach <dmitry@openratings.com>; +Cc: pgsql-sql

Dmitry Tkach <dmitry@openratings.com> writes:
> Does btree require a complete order defined?

Yes, absolutely.  I do not think that btree is a useful index type for
your problem.  Nor rtree (our rtree implementation can only do 2-D
AFAIK).

You might have better luck with GIST.  In particular contrib/intarray
would be worth looking at for inspiration.  (You could even use it
directly if you cared to change your data representation, I think.)

			regards, tom lane



^ permalink  raw  reply  [nested|flat] 12+ messages in thread

* Btree index extension question
@ 2002-03-15 18:04  Dmitry Tkach <dmitry@openratings.com>
  0 siblings, 1 reply; 12+ messages in thread

From: Dmitry Tkach @ 2002-03-15 18:04 UTC (permalink / raw)
  To: pgsql-admin@postgresql.org.pgsql-general

Hi, everybody!

I was wonderring if there is somebody out there who could help me with 
understand how index extensions work...
Let me state the problem first.

I have many (15) boolean attributes and I need to be able to search the 
database for entries with any combination of those attributes for being 
true. For example - find all the entries, where a1=a2=a3=true or find 
all the entries where a1=a2=a4=true etc...
Because there are so many of them (and the database is HUGE), putting 
every attribute into a separate column and creating a separate index on 
every possible combination, is really out of the question.
So, I was thinking about creating a single int2 column, with each bit 
representing an attribute - so that, the first query I quoted above 
would look like "select * from table where attributes & 7 = 7", and the 
other query would be
"select * from table where attributes & 11 = 11' etc...

This looked so beautiful to me, but now I am stuck trying to index that 
table  [:-(]

I started off, hoping to get away with btrees.

I defined an operator >>=(int2,int2) as 'select $1&$2=$2;'
It looks nice so far, but then the question is - what do I do with the 
other operations? By analogy with 'normal' comparison operators, I would do:

 >> (I know the name is taken  [:-)]  as 'select not $2 >>= $1'
=<<                                  as 'select $2 >>= $1'
<<                                   as 'select not $1 >>= $2'
... and leave '=' intact.

But then I realized, that these set of operators, does not really define 
a complete order - for example, if I compare, say, 5 and 3:
5 & 3 = 1, 3 & 5 = 1, so I get BOTH 5 << 3 and 5 >> 3 being true at the 
same time  [:-(]

So my question is, first of all, is that a problem? Does btree require a 
complete order defined? Will it work with partial order?
Secondly, if it is a problem, perhaps, I am missing something here, 
assuming that there is no way to define a set of operations to do what I 
want and provide a completely ordered set (or do I need it to define a 
perfect complete order - what exactly is required for btree to work? Any 
ideas?)

And finally, if there is just no way I could get away with btrees, can I 
make an rtree to work for me? Could somebody explain to me (or point me 
to a doc somewhere) the meaning of the strategies (and requirements - 
like transitivity etc...) I need for an rtree, and also what support 
functions (like comparison func in case of a btree) do I need?

Thank you very much for your attention.
Any input will be greatly appreciated.

Dima




^ permalink  raw  reply  [nested|flat] 12+ messages in thread

* Btree index extension question
@ 2002-03-15 18:20  Dmitry Tkach <dmitry@openratings.com>
  0 siblings, 2 replies; 12+ messages in thread

From: Dmitry Tkach @ 2002-03-15 18:20 UTC (permalink / raw)
  To: pgsql-sql

Hi, everybody!

I was wonderring if there is somebody out there who could help me with 
understand how index extensions work...
Let me state the problem first.

I have many (15) boolean attributes and I need to be able to search the 
database for entries with any combination of those attributes for being 
true. For example - find all the entries, where a1=a2=a3=true or find 
all the entries where a1=a2=a4=true etc...
Because there are so many of them (and the database is HUGE), putting 
every attribute into a separate column and creating a separate index on 
every possible combination, is really out of the question.
So, I was thinking about creating a single int2 column, with each bit 
representing an attribute - so that, the first query I quoted above 
would look like "select * from table where attributes & 7 = 7", and the 
other query would be
"select * from table where attributes & 11 = 11' etc...

This looked so beautiful to me, but now I am stuck trying to index that 
table  [:-(]

I started off, hoping to get away with btrees.

I defined an operator >>=(int2,int2) as 'select $1&$2=$2;'
It looks nice so far, but then the question is - what do I do with the 
other operations? By analogy with 'normal' comparison operators, I would do: 


 >> (I know the name is taken  [:-)]  as 'select not $2 >>= $1'
=<<                                  as 'select $2 >>= $1'
<<                                   as 'select not $1 >>= $2'
... and leave '=' intact.

But then I realized, that these set of operators, does not really define 
a complete order - for example, if I compare, say, 5 and 3:
5 & 3 = 1, 3 & 5 = 1, so I get BOTH 5 << 3 and 5 >> 3 being true at the 
same time  [:-(]

So my question is, first of all, is that a problem? Does btree require a 
complete order defined? Will it work with partial order?
Secondly, if it is a problem, perhaps, I am missing something here, 
assuming that there is no way to define a set of operations to do what I 
want and provide a completely ordered set (or do I need it to define a 
perfect complete order - what exactly is required for btree to work? Any 
ideas?)

And finally, if there is just no way I could get away with btrees, can I 
make an rtree to work for me? Could somebody explain to me (or point me 
to a doc somewhere) the meaning of the strategies (and requirements - 
like transitivity etc...) I need for an rtree, and also what support 
functions (like comparison func in case of a btree) do I need?

Thank you very much for your attention.
Any input will be greatly appreciated.

Dima





^ permalink  raw  reply  [nested|flat] 12+ messages in thread

* Re: Btree index extension question
@ 2002-03-15 19:31  Dmitry Tkach <dmitry@openratings.com>
  parent: Tom Lane <tgl@sss.pgh.pa.us>
  0 siblings, 0 replies; 12+ messages in thread

From: Dmitry Tkach @ 2002-03-15 19:31 UTC (permalink / raw)
  To: Tom Lane <tgl@sss.pgh.pa.us>; +Cc: pgsql-sql

Tom Lane wrote:

>  Nor rtree (our rtree implementation can only do 2-D
>AFAIK).
>
I know that... But, I thought, if I knew the set of requirements for the 
rtree strategies and support funcs., I could come up with a set of 
functions that would simulate the 2-D metrics, yet do what I need... 
(ALL that I need really is to test if a & b = b - I just can't believe 
there is no simple way to do that!).

>
>
>You might have better luck with GIST.  In particular contrib/intarray
>would be worth looking at for inspiration.  
>
Yeah... I looked at it... It scared the hell out of me - seemed to be 
too damn complicated :-)
I mean, I just can't affort spending months on this thing - I have a 
huge project to work on, and this is just one , really small, part of it...
Perhaps, if I it was documented a little better, I would be able to make 
some sense of it in a reasonable time, but just going through all that 
code and trying to guess what it is used for, doesn't look like an 
option to me (especially, provided that I am not familiar with postgres 
sources it is using, so, it is really a lot more stuff for me to go 
through) :-(

>(You could even use it
>directly if you cared to change your data representation, I think.)
>
You mean to use an array of 15 ints instead of a single bit-packed 
representation?
Well... I said before - the table is HUGE (60 million of rows), and 
these 15 attributes is not the only stuff in it... So, my immediate 
concern about changing the representation is if I am going to be able to 
afford so much more disk space...

And then, there are other issues... I wanted it to be a btree, to begin 
with, because these are not the only 15 attributes I need to use in the 
search criteria - so, I was hoping to use a multicolumn btree, with my 
bitset just being one of many columns in it... and if I opt for a gist 
(or even an rtree), that's not an option...

Ohh... tough luck - sounds like I am going to have to stick with a 
"straight" btree index, plus a lot of postprocessing afterwards :-(

Dima





^ permalink  raw  reply  [nested|flat] 12+ messages in thread

* Re: [GENERAL] Btree index extension question
@ 2002-03-15 21:15  fcanedo@hotpop.com
  parent: Dmitry Tkach <dmitry@openratings.com>
  0 siblings, 1 reply; 12+ messages in thread

From: fcanedo@hotpop.com @ 2002-03-15 21:15 UTC (permalink / raw)
  To: Dmitry Tkach <dmitry@openratings.com>; +Cc: pgsql-admin@postgresql.org; pgsql-general@postgresql.org; pgsql-sql

Hi,

Don't know enough about postgresql to be sure about this, but here goes:

If postgresql does bitwise operations, then you can use that instead of
defining new operators. Just construct a number for all the columns that
need to be true and do a bitwise 'and' with the stored value. (eg. (7 &
stored_val) = 7)

If postgresql uses an index to supply functions with their parameters,
then make a function that'll do the comparison for you and use it in your
query.  Or make the index (on all the columns) and make a function that
takes all the columns as the parameters to compare against (and ofcourse
the values that you want to check against). That way you always use the
columns of the index in the correct order.

Somebody please check this, as I may have been hit with a stupid-stick.

On Fri, 15 Mar 2002, Dmitry Tkach wrote:

> Hi, everybody!
>
> I was wonderring if there is somebody out there who could help me with
> understand how index extensions work...
> Let me state the problem first.
>
> I have many (15) boolean attributes and I need to be able to search the
> database for entries with any combination of those attributes for being
> true. For example - find all the entries, where a1=a2=a3=true or find
> all the entries where a1=a2=a4=true etc...
> Because there are so many of them (and the database is HUGE), putting
> every attribute into a separate column and creating a separate index on
> every possible combination, is really out of the question.
> So, I was thinking about creating a single int2 column, with each bit
> representing an attribute - so that, the first query I quoted above
> would look like "select * from table where attributes & 7 = 7", and the
> other query would be
> "select * from table where attributes & 11 = 11' etc...
>
> This looked so beautiful to me, but now I am stuck trying to index that
> table  [:-(]
>
> I started off, hoping to get away with btrees.
>
> I defined an operator >>=(int2,int2) as 'select $1&$2=$2;'
> It looks nice so far, but then the question is - what do I do with the
> other operations? By analogy with 'normal' comparison operators, I would do:
>
>  >> (I know the name is taken  [:-)]  as 'select not $2 >>= $1'
> =<<                                  as 'select $2 >>= $1'
> <<                                   as 'select not $1 >>= $2'
> .. and leave '=' intact.
>
> But then I realized, that these set of operators, does not really define
> a complete order - for example, if I compare, say, 5 and 3:
> 5 & 3 = 1, 3 & 5 = 1, so I get BOTH 5 << 3 and 5 >> 3 being true at the
> same time  [:-(]
>
> So my question is, first of all, is that a problem? Does btree require a
> complete order defined? Will it work with partial order?
> Secondly, if it is a problem, perhaps, I am missing something here,
> assuming that there is no way to define a set of operations to do what I
> want and provide a completely ordered set (or do I need it to define a
> perfect complete order - what exactly is required for btree to work? Any
> ideas?)
>
> And finally, if there is just no way I could get away with btrees, can I
> make an rtree to work for me? Could somebody explain to me (or point me
> to a doc somewhere) the meaning of the strategies (and requirements -
> like transitivity etc...) I need for an rtree, and also what support
> functions (like comparison func in case of a btree) do I need?
>
> Thank you very much for your attention.
> Any input will be greatly appreciated.
>
> Dima
>
>
> ---------------------------(end of broadcast)---------------------------
> TIP 2: you can get off all lists at once with the unregister command
>     (send "unregister YourEmailAddressHere" to majordomo@postgresql.org)
>






^ permalink  raw  reply  [nested|flat] 12+ messages in thread

* Re: [GENERAL] Btree index extension question
@ 2002-03-15 21:57  fcanedo@hotpop.com
  parent: Dmitry Tkach <dmitry@openratings.com>
  0 siblings, 1 reply; 12+ messages in thread

From: fcanedo@hotpop.com @ 2002-03-15 21:57 UTC (permalink / raw)
  To: Dmitry Tkach <dmitry@openratings.com>; +Cc: fcanedo@hotpop.com; pgsql-admin@postgresql.org; pgsql-general@postgresql.org; pgsql-sql



On Fri, 15 Mar 2002, Dmitry Tkach wrote:

> fcanedo@hotpop.com wrote:
>
> >
> >If postgresql does bitwise operations, then you can use that instead of
> >defining new operators. Just construct a number for all the columns that
> >need to be true and do a bitwise 'and' with the stored value. (eg. (7 &
> >stored_val) = 7)
> >
>
> Yeah... The thing is that I want to be able to the index. And to use the
> index, I need BOOLEAN
> operators (this seems to be the LEAST of my problems,but anyway) - so, I
> have to define 'wrappers' around the standard bitwise operations - e.g.
> a <<= b   ---> a & b = a;


Ok, let's see whether we understand each other:

1. Make a column that contains the bitstring of your 15 boolean
columns. Let's call it bitstring.
2. bitstring is calculated on each insert or update by a trigger.
3. Make an index on bitstring.
4. Make a query to find the records that have a1, a2 and a3 set to true,
like so:

SELECT * FROM table where (bitstring & 7) = 7;

Will this not give you the correct answer and use the index on bitstring?






^ permalink  raw  reply  [nested|flat] 12+ messages in thread

* Re: Btree index extension question
@ 2002-03-15 23:09  Dmitry Tkach <dmitry@openratings.com>
  parent: fcanedo@hotpop.com
  0 siblings, 1 reply; 12+ messages in thread

From: Dmitry Tkach @ 2002-03-15 23:09 UTC (permalink / raw)
  To: fcanedo@hotpop.com; +Cc: pgsql-admin@postgresql.org; pgsql-general@postgresql.org; pgsql-sql

fcanedo@hotpop.com wrote:

>
>If postgresql does bitwise operations, then you can use that instead of
>defining new operators. Just construct a number for all the columns that
>need to be true and do a bitwise 'and' with the stored value. (eg. (7 &
>stored_val) = 7)
>

Yeah... The thing is that I want to be able to the index. And to use the 
index, I need BOOLEAN
operators (this seems to be the LEAST of my problems,but anyway) - so, I 
have to define 'wrappers' around the standard bitwise operations - e.g. 
a <<= b   ---> a & b = a;

>
>
>If postgresql uses an index to supply functions with their parameters,
>then make a function that'll do the comparison for you and use it in your
>query. 
>

Well ... that's the point - can't do that :-(
You can create functional indexes in postgres (and anywhere else AFAIK), 
but the function must take a SINGLE parameter.
In other words, the only way to do what I need would be to create 15 
functions, like:
check_bit_1 (x) return x & 1 = 1;
check_bit_2 (x) return x & 2 = 2;
etc...
And then create 15 different indexes (one for each func).

But even that would not be of much help, because I need to search by a 
COMBINATION of
parameters, and need a COMPOUND index to do that, not a separate index 
for each attr...

> Or make the index (on all the columns) and make a function that
>takes all the columns as the parameters to compare against (and ofcourse
>the values that you want to check against). That way you always use the
>columns of the index in the correct order.
>

I am not sure I understand this suggestion... If I make the index on all 
the columns, I would need to specify all the (leftmost) values in the 
search criteria to be able to use it, right?
For example, suppose, I have an index on (a,b,c) - then
select * from foo where a=bar and b=bar will work, but
select * from foo where b=bar and c=bar will not...

That's exactly my problem - I need to be able to search by any 
combination of the values - (a),(b),(c),(ab),(ac),(bc),(abc)
... only I have 15 of them - too many combinations to consider buidling 
indexes for any of them :-(





^ permalink  raw  reply  [nested|flat] 12+ messages in thread

* Re: Btree index extension question
@ 2002-03-15 23:37  Dmitry Tkach <dmitry@openratings.com>
  parent: fcanedo@hotpop.com
  0 siblings, 1 reply; 12+ messages in thread

From: Dmitry Tkach @ 2002-03-15 23:37 UTC (permalink / raw)
  To: fcanedo@hotpop.com; +Cc: pgsql-admin@postgresql.org; pgsql-general@postgresql.org; pgsql-sql

>
>
>
>SELECT * FROM table where (bitstring & 7) = 7;
>
>Will this not give you the correct answer and use the index on bitstring?
>
Yes, and know... (Yes, it will give th ecorrect answer, and NO it will 
not use the index).
The thing is, that it will only use a (btree) index for one of the 
'comparison' operators
(<=, <, =, >, >=), that compare the value in the table with the query 
parameter - so,
bitstring = 7, or bitstring < 7 etc... will work, but 
'do_something_to_bitstring = 7' will not (I mean, it will, but it won't 
use the index).

So, the idea is to redefine those comparison operators for the index, so 
that I could use one of them fopr my purpose - for example (as I 
mentioned in the original message), I was trying to define a '<<=' 
("less or equals") operator as a <<= b iff a & b = a.
My problem is that (as far as I understand) the way I am doing it will 
not work (my set of operators doesn't define a strict ordering, so that 
not any pair of values is comparable) :-(

And what I am looking for is either a suggestion of how this strict 
ordering can be defined, or a description of what exactly the btree 
needs to work (I suspect, that completely strict ordering is not really 
necesssary, and that I could get away with some kind of a partial order, 
if I new exactly what the btree stuff is looking for)...

Dima







^ permalink  raw  reply  [nested|flat] 12+ messages in thread

* Re: [GENERAL] Btree index extension question
@ 2002-03-16 00:09  fcanedo@hotpop.com
  parent: Dmitry Tkach <dmitry@openratings.com>
  0 siblings, 1 reply; 12+ messages in thread

From: fcanedo@hotpop.com @ 2002-03-16 00:09 UTC (permalink / raw)
  To: Dmitry Tkach <dmitry@openratings.com>; +Cc: fcanedo@hotpop.com; pgsql-admin@postgresql.org; pgsql-general@postgresql.org; pgsql-sql



On Fri, 15 Mar 2002, Dmitry Tkach wrote:

...
> Yes, and know... (Yes, it will give th ecorrect answer, and NO it will
> not use the index).
> The thing is, that it will only use a (btree) index for one of the
> 'comparison' operators
> (<=, <, =, >, >=), that compare the value in the table with the query
> parameter - so,
> bitstring = 7, or bitstring < 7 etc... will work, but
> 'do_something_to_bitstring = 7' will not (I mean, it will, but it won't
> use the index).


Okay, I'm recovering from my encounter with the stupid stick.

I understand this:
1. You want to use a btree index because presumably it's faster than a
normal index.
2. A btree index is a binary tree index that uses the order of values to
find an answer quickly.
3. In your case for instance: a value of 10 should produce a resultset
with bitstrings of 10, 11, 14, 26, ...

So yeah, since 12 and 13 are > 10, normal equality operators won't work.

If a solution were to be found, I think it should base the ordering on
the bits from least significant bit to most significant. So, for 1st bit
go left in the tree for a 0 and right for a 1 and same for next bit.
But no, this won't work since you don't care about the other boolean
columns, solong as the ones your looking for are true! To clarify, if you
don't care about the first column/bit, values from both the left and the
right parts of the binary tree can be valid.

Wild guess: base the ordering on the number of bits and then try to
narrow it down in the select with an equal operator.

SELECT * FROM TABLE
WHERE bitstring > 7
AND bitstring = 7;

Wouldn't know how to get this to work though! :(


Oracle has a special index type for just this case. I think they call
them bitmap indexes.







^ permalink  raw  reply  [nested|flat] 12+ messages in thread

* Re: Btree index extension question
@ 2002-03-16 01:50  Dmitry Tkach <dmitry@openratings.com>
  parent: fcanedo@hotpop.com
  0 siblings, 0 replies; 12+ messages in thread

From: Dmitry Tkach @ 2002-03-16 01:50 UTC (permalink / raw)
  To: fcanedo@hotpop.com; +Cc: pgsql-general@postgresql.org; pgsql-sql

fcanedo@hotpop.com wrote:

>
>
>I understand this:
>1. You want to use a btree index because presumably it's faster than a
>normal index.
>
Ahhh.. What do you mean by 'normal index'?
I have two reasons to use btree:
- It is simpler to implement;
- It can be used in combination with other columns (these 15 boolean 
flags is not the only stuff I need to search by, so, I am going to have 
to run queries like '... where flags & 33 = 33 and foo=bar'' - to do 
that, I would need an index on (flags 'bit_ops', foo), where bit_ops is 
my special set of operations I am looking to define). If I am not using 
btree for the flags, I would then have to define the whole indexing 
strategy for all my columns, and I am really hoping to be able to avoid 
having to do that.

>
>2. A btree index is a binary tree index that uses the order of values to
>find an answer quickly.
>
Yep.

>
>3. In your case for instance: a value of 10 should produce a resultset
>with bitstrings of 10, 11, 14, 26, ...
>
Yep.

>
>Wouldn't know how to get this to work though! :(
>

Yeah... me neither :-(
I am about to give up on this (hate to do that!)...

I was trying to make use of a GiST index now, but having some problems 
with that too :-(
Could you please look at the next message I am about to post in a few 
minutes (about debugging C functions)? Perhaps, you would have some 
helpful ideas there?

Thanks!


Dima






^ permalink  raw  reply  [nested|flat] 12+ messages in thread

* Re: Btree index extension question
@ 2002-03-17 03:51  Christopher Kings-Lynne <chriskl@familyhealth.com.au>
  parent: Dmitry Tkach <dmitry@openratings.com>
  1 sibling, 1 reply; 12+ messages in thread

From: Christopher Kings-Lynne @ 2002-03-17 03:51 UTC (permalink / raw)
  To: Dmitry Tkach <dmitry@openratings.com>; pgsql-sql

Why don't you use the 'varbit' or 'bit' type?

Chris

----- Original Message -----
From: "Dmitry Tkach" <dmitry@openratings.com>
To: <pgsql-sql@postgresql.org>
Sent: Saturday, March 16, 2002 2:20 AM
Subject: [SQL] Btree index extension question


> Hi, everybody!
>
> I was wonderring if there is somebody out there who could help me with
> understand how index extensions work...
> Let me state the problem first.
>
> I have many (15) boolean attributes and I need to be able to search the
> database for entries with any combination of those attributes for being
> true. For example - find all the entries, where a1=a2=a3=true or find
> all the entries where a1=a2=a4=true etc...
> Because there are so many of them (and the database is HUGE), putting
> every attribute into a separate column and creating a separate index on
> every possible combination, is really out of the question.
> So, I was thinking about creating a single int2 column, with each bit
> representing an attribute - so that, the first query I quoted above
> would look like "select * from table where attributes & 7 = 7", and the
> other query would be
> "select * from table where attributes & 11 = 11' etc...
>
> This looked so beautiful to me, but now I am stuck trying to index that
> table  [:-(]
>
> I started off, hoping to get away with btrees.
>
> I defined an operator >>=(int2,int2) as 'select $1&$2=$2;'
> It looks nice so far, but then the question is - what do I do with the
> other operations? By analogy with 'normal' comparison operators, I would
do:
>
>
>  >> (I know the name is taken  [:-)]  as 'select not $2 >>= $1'
> =<<                                  as 'select $2 >>= $1'
> <<                                   as 'select not $1 >>= $2'
> ... and leave '=' intact.
>
> But then I realized, that these set of operators, does not really define
> a complete order - for example, if I compare, say, 5 and 3:
> 5 & 3 = 1, 3 & 5 = 1, so I get BOTH 5 << 3 and 5 >> 3 being true at the
> same time  [:-(]
>
> So my question is, first of all, is that a problem? Does btree require a
> complete order defined? Will it work with partial order?
> Secondly, if it is a problem, perhaps, I am missing something here,
> assuming that there is no way to define a set of operations to do what I
> want and provide a completely ordered set (or do I need it to define a
> perfect complete order - what exactly is required for btree to work? Any
> ideas?)
>
> And finally, if there is just no way I could get away with btrees, can I
> make an rtree to work for me? Could somebody explain to me (or point me
> to a doc somewhere) the meaning of the strategies (and requirements -
> like transitivity etc...) I need for an rtree, and also what support
> functions (like comparison func in case of a btree) do I need?
>
> Thank you very much for your attention.
> Any input will be greatly appreciated.
>
> Dima
>
>
>
> ---------------------------(end of broadcast)---------------------------
> TIP 6: Have you searched our list archives?
>
> http://archives.postgresql.org
>




^ permalink  raw  reply  [nested|flat] 12+ messages in thread

* Re: Btree index extension question
@ 2002-03-17 04:07  Dima Tkach <dmitry@openratings.com>
  parent: Christopher Kings-Lynne <chriskl@familyhealth.com.au>
  0 siblings, 0 replies; 12+ messages in thread

From: Dima Tkach @ 2002-03-17 04:07 UTC (permalink / raw)
  To: Christopher Kings-Lynne <chriskl@familyhealth.com.au>; +Cc: pgsql-sql

Christopher Kings-Lynne wrote:

>Why don't you use the 'varbit' or 'bit' type?
>
Because it doesn't solve anything - there is no way to create an index 
with that type to do the sort of queries I need :-(




^ permalink  raw  reply  [nested|flat] 12+ messages in thread


end of thread, other threads:[~2002-03-17 04:07 UTC | newest]

Thread overview: 12+ messages (download: mbox mbox.gz follow: Atom feed)
-- links below jump to the message on this page --
2002-03-15 18:04 Btree index extension question Dmitry Tkach <dmitry@openratings.com>
2002-03-15 21:15 ` fcanedo@hotpop.com
2002-03-15 23:09   ` Dmitry Tkach <dmitry@openratings.com>
2002-03-15 21:57     ` fcanedo@hotpop.com
2002-03-15 23:37       ` Dmitry Tkach <dmitry@openratings.com>
2002-03-16 00:09         ` fcanedo@hotpop.com
2002-03-16 01:50           ` Dmitry Tkach <dmitry@openratings.com>
2002-03-15 18:20 Btree index extension question Dmitry Tkach <dmitry@openratings.com>
2002-03-15 17:06 ` Tom Lane <tgl@sss.pgh.pa.us>
2002-03-15 19:31   ` Dmitry Tkach <dmitry@openratings.com>
2002-03-17 03:51 ` Christopher Kings-Lynne <chriskl@familyhealth.com.au>
2002-03-17 04:07   ` Dima Tkach <dmitry@openratings.com>

This inbox is served by DDX for PostgreSQL; see mirroring instructions
for how to clone and mirror all data and code used for this inbox