Revision cbe81673 snf-pithos-backend/pithos/backends/lib/sqlalchemy/node.py
| b/snf-pithos-backend/pithos/backends/lib/sqlalchemy/node.py | ||
|---|---|---|
| 674 | 674 |
# This is why the full path is stored. |
| 675 | 675 |
if before != inf: |
| 676 | 676 |
s = select([func.count(v.c.serial), |
| 677 |
func.sum(v.c.size), |
|
| 678 |
func.max(v.c.mtime)]) |
|
| 677 |
func.sum(v.c.size),
|
|
| 678 |
func.max(v.c.mtime)])
|
|
| 679 | 679 |
c1 = select([func.max(self.versions.c.serial)], |
| 680 | 680 |
and_(self.versions.c.mtime < before, |
| 681 | 681 |
self.versions.c.node == v.c.node)) |
| 682 | 682 |
else: |
| 683 | 683 |
inner_join = \ |
| 684 |
self.versions.join(self.nodes, onclause=\ |
|
| 685 |
self.versions.c.serial == self.nodes.c.latest_version) |
|
| 684 |
self.versions.join(self.nodes, onclause= |
|
| 685 |
self.versions.c.serial == |
|
| 686 |
self.nodes.c.latest_version) |
|
| 686 | 687 |
s = select([func.count(self.versions.c.serial), |
| 687 |
func.sum(self.versions.c.size), |
|
| 688 |
func.max(self.versions.c.mtime)], from_obj=[inner_join]) |
|
| 688 |
func.sum(self.versions.c.size), |
|
| 689 |
func.max(self.versions.c.mtime)], |
|
| 690 |
from_obj=[inner_join]) |
|
| 689 | 691 |
|
| 690 | 692 |
c2 = select([self.nodes.c.node], |
| 691 | 693 |
self.nodes.c.path.like(self.escape_like(path) + '%', |
| 692 | 694 |
escape=ESCAPE_CHAR)) |
| 693 | 695 |
if before != inf: |
| 694 | 696 |
s = s.where(and_(v.c.serial == c1, |
| 695 |
v.c.cluster != except_cluster,
|
|
| 696 |
v.c.node.in_(c2)))
|
|
| 697 |
v.c.cluster != except_cluster, |
|
| 698 |
v.c.node.in_(c2))) |
|
| 697 | 699 |
else: |
| 698 | 700 |
s = s.where(and_(self.versions.c.cluster != except_cluster, |
| 699 | 701 |
self.versions.c.node.in_(c2))) |
| ... | ... | |
| 999 | 1001 |
v.c.node == self.versions.c.node)) |
| 1000 | 1002 |
else: |
| 1001 | 1003 |
filtered = select([self.nodes.c.latest_version]) |
| 1002 |
filtered = filtered.where(self.nodes.c.node == \ |
|
| 1003 |
self.versions.c.node).correlate(self.versions) |
|
| 1004 |
filtered = filtered.where(self.nodes.c.node == |
|
| 1005 |
self.versions.c.node |
|
| 1006 |
).correlate(self.versions) |
|
| 1004 | 1007 |
s = s.where(self.versions.c.serial == filtered) |
| 1005 | 1008 |
s = s.where(self.versions.c.cluster != except_cluster) |
| 1006 | 1009 |
s = s.where(self.versions.c.node.in_(select([self.nodes.c.node], |
| 1007 |
self.nodes.c.parent == parent))) |
|
| 1010 |
self.nodes.c.parent == parent)))
|
|
| 1008 | 1011 |
s = s.where(self.attributes.c.serial == self.versions.c.serial) |
| 1009 | 1012 |
s = s.where(self.attributes.c.domain == domain) |
| 1010 | 1013 |
s = s.where(self.nodes.c.node == self.versions.c.node) |
| ... | ... | |
| 1013 | 1016 |
conjb = [] |
| 1014 | 1017 |
for path, match in pathq: |
| 1015 | 1018 |
if match == MATCH_PREFIX: |
| 1016 |
conja.append(self.nodes.c.path.like(self.escape_like(path) + '%',
|
|
| 1017 |
escape=ESCAPE_CHAR)) |
|
| 1019 |
conja.append(self.nodes.c.path.like(self.escape_like(path) + |
|
| 1020 |
'%', escape=ESCAPE_CHAR))
|
|
| 1018 | 1021 |
elif match == MATCH_EXACT: |
| 1019 | 1022 |
conjb.append(path) |
| 1020 | 1023 |
if conja or conjb: |
| 1021 |
s = s.where(or_(self.nodes.c.path.in_(conjb),*conja)) |
|
| 1024 |
s = s.where(or_(self.nodes.c.path.in_(conjb), *conja))
|
|
| 1022 | 1025 |
rp = self.conn.execute(s) |
| 1023 | 1026 |
rows = rp.fetchall() |
| 1024 | 1027 |
rp.close() |
| ... | ... | |
| 1090 | 1093 |
and_(v.c.mtime < before, |
| 1091 | 1094 |
v.c.node == self.versions.c.node)) |
| 1092 | 1095 |
inner_join = \ |
| 1093 |
self.nodes.join(self.versions,
|
|
| 1094 |
onclause=self.versions.c.serial==filtered)
|
|
| 1096 |
self.nodes.join(self.versions, |
|
| 1097 |
onclause=self.versions.c.serial == filtered)
|
|
| 1095 | 1098 |
else: |
| 1096 | 1099 |
filtered = select([self.nodes.c.latest_version]) |
| 1097 |
filtered = filtered.where(self.nodes.c.node == self.versions.c.node).correlate(self.versions) |
|
| 1100 |
filtered = filtered.where(self.nodes.c.node == |
|
| 1101 |
self.versions.c.node |
|
| 1102 |
).correlate(self.versions) |
|
| 1098 | 1103 |
inner_join = \ |
| 1099 |
self.nodes.join(self.versions,
|
|
| 1100 |
onclause=\
|
|
| 1101 |
self.versions.c.serial==filtered)
|
|
| 1104 |
self.nodes.join(self.versions, |
|
| 1105 |
onclause=
|
|
| 1106 |
self.versions.c.serial == filtered)
|
|
| 1102 | 1107 |
if not all_props: |
| 1103 | 1108 |
s = select([self.nodes.c.path, |
| 1104 |
self.versions.c.serial],from_obj=[inner_join]).distinct() |
|
| 1109 |
self.versions.c.serial], |
|
| 1110 |
from_obj=[inner_join]).distinct() |
|
| 1105 | 1111 |
else: |
| 1106 | 1112 |
s = select([self.nodes.c.path, |
| 1107 |
self.versions.c.serial, self.versions.c.node, |
|
| 1108 |
self.versions.c.hash, |
|
| 1109 |
self.versions.c.size, self.versions.c.type, |
|
| 1110 |
self.versions.c.source, |
|
| 1111 |
self.versions.c.mtime, self.versions.c.muser, |
|
| 1112 |
self.versions.c.uuid, |
|
| 1113 |
self.versions.c.checksum, |
|
| 1114 |
self.versions.c.cluster],from_obj=[inner_join]).distinct() |
|
| 1113 |
self.versions.c.serial, self.versions.c.node, |
|
| 1114 |
self.versions.c.hash, |
|
| 1115 |
self.versions.c.size, self.versions.c.type, |
|
| 1116 |
self.versions.c.source, |
|
| 1117 |
self.versions.c.mtime, self.versions.c.muser, |
|
| 1118 |
self.versions.c.uuid, |
|
| 1119 |
self.versions.c.checksum, |
|
| 1120 |
self.versions.c.cluster], |
|
| 1121 |
from_obj=[inner_join]).distinct() |
|
| 1115 | 1122 |
|
| 1116 | 1123 |
s = s.where(self.versions.c.cluster != except_cluster) |
| 1117 | 1124 |
s = s.where(self.versions.c.node.in_(select([self.nodes.c.node], |
| ... | ... | |
| 1119 | 1126 |
|
| 1120 | 1127 |
s = s.where(self.versions.c.node == self.nodes.c.node) |
| 1121 | 1128 |
s = s.where(and_(self.nodes.c.path > bindparam('start'),
|
| 1122 |
self.nodes.c.path < nextling))
|
|
| 1129 |
self.nodes.c.path < nextling))
|
|
| 1123 | 1130 |
conja = [] |
| 1124 | 1131 |
conjb = [] |
| 1125 | 1132 |
for path, match in pathq: |
| 1126 | 1133 |
if match == MATCH_PREFIX: |
| 1127 |
conja.append(self.nodes.c.path.like(self.escape_like(path) + '%',
|
|
| 1128 |
escape=ESCAPE_CHAR)) |
|
| 1134 |
conja.append(self.nodes.c.path.like(self.escape_like(path) + |
|
| 1135 |
'%', escape=ESCAPE_CHAR))
|
|
| 1129 | 1136 |
elif match == MATCH_EXACT: |
| 1130 | 1137 |
conjb.append(path) |
| 1131 | 1138 |
if conja or conjb: |
| 1132 |
s = s.where(or_(self.nodes.c.path.in_(conjb),*conja)) |
|
| 1139 |
s = s.where(or_(self.nodes.c.path.in_(conjb), *conja))
|
|
| 1133 | 1140 |
|
| 1134 | 1141 |
if sizeq and len(sizeq) == 2: |
| 1135 | 1142 |
if sizeq[0]: |
| ... | ... | |
| 1142 | 1149 |
included, excluded, opers = parse_filters(filterq) |
| 1143 | 1150 |
if included: |
| 1144 | 1151 |
subs = select([1]) |
| 1145 |
subs = subs.where(self.attributes.c.serial == self.versions.c.serial).correlate(self.versions) |
|
| 1152 |
subs = subs.where(self.attributes.c.serial == |
|
| 1153 |
self.versions.c.serial |
|
| 1154 |
).correlate(self.versions) |
|
| 1146 | 1155 |
subs = subs.where(self.attributes.c.domain == domain) |
| 1147 |
subs = subs.where(or_(*[self.attributes.c.key.op('=')(x) for x in included]))
|
|
| 1156 |
subs = subs.where(or_(*[self.attributes.c.key.op('=')(x)
|
|
| 1157 |
for x in included])) |
|
| 1148 | 1158 |
s = s.where(exists(subs)) |
| 1149 | 1159 |
if excluded: |
| 1150 | 1160 |
subs = select([1]) |
| 1151 |
subs = subs.where(self.attributes.c.serial == self.versions.c.serial).correlate(self.versions) |
|
| 1161 |
subs = subs.where(self.attributes.c.serial == |
|
| 1162 |
self.versions.c.serial |
|
| 1163 |
).correlate(self.versions) |
|
| 1152 | 1164 |
subs = subs.where(self.attributes.c.domain == domain) |
| 1153 |
subs = subs.where(or_(*[self.attributes.c.key.op('=')(x) for x in excluded]))
|
|
| 1165 |
subs = subs.where(or_(*[self.attributes.c.key.op('=')(x)
|
|
| 1166 |
for x in excluded])) |
|
| 1154 | 1167 |
s = s.where(not_(exists(subs))) |
| 1155 | 1168 |
if opers: |
| 1156 | 1169 |
for k, o, val in opers: |
| 1157 | 1170 |
subs = select([1]) |
| 1158 |
subs = subs.where(self.attributes.c.serial == self.versions.c.serial).correlate(self.versions) |
|
| 1171 |
subs = subs.where(self.attributes.c.serial == |
|
| 1172 |
self.versions.c.serial |
|
| 1173 |
).correlate(self.versions) |
|
| 1159 | 1174 |
subs = subs.where(self.attributes.c.domain == domain) |
| 1160 | 1175 |
subs = subs.where( |
| 1161 |
and_(self.attributes.c.key.op('=')(k), self.attributes.c.value.op(o)(val)))
|
|
| 1176 |
and_(self.attributes.c.key.op('=')(k),
|
|
| 1177 |
self.attributes.c.value.op(o)(val))) |
|
| 1162 | 1178 |
s = s.where(exists(subs)) |
| 1163 | 1179 |
|
| 1164 | 1180 |
s = s.order_by(self.nodes.c.path) |
| ... | ... | |
| 1264 | 1280 |
def get_props(self, paths): |
| 1265 | 1281 |
inner_join = \ |
| 1266 | 1282 |
self.nodes.join(self.versions, |
| 1267 |
onclause=self.versions.c.serial == self.nodes.c.latest_version) |
|
| 1283 |
onclause=self.versions.c.serial == |
|
| 1284 |
self.nodes.c.latest_version) |
|
| 1268 | 1285 |
cc = self.nodes.c.path.in_(paths) |
| 1269 | 1286 |
s = select([self.nodes.c.path, self.versions.c.type], |
| 1270 |
from_obj=[inner_join]).where(cc).distinct()
|
|
| 1287 |
from_obj=[inner_join]).where(cc).distinct() |
|
| 1271 | 1288 |
r = self.conn.execute(s) |
| 1272 | 1289 |
rows = r.fetchall() |
| 1273 | 1290 |
r.close() |
Also available in: Unified diff